1c/OpenIntegrations
1
0
Fork 0
mirror of https://github.com/Bayselonarrend/OpenIntegrations.git synced 2025-03-31 22:05:13 +02:00
Code Issues Releases Activity

Скрипт автоформатирования модулей

Browse Source
This commit is contained in:
Anton 2024-07-27 14:37:04 +03:00
parent e58b2e318e
commit 0211b78acc
83 changed files with 35392 additions and 35183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.github/workflows/oint_convert.yml vendored
View File

@ -47,6 +47,9 @@ jobs:
- name: Обновить Workflow тестирования OInt (EN)
run: oscript ./.github/workflows/os/oint_testmaker_en.os
- name: Скрипт форматирования модулей
run: oscript ./.github/workflows/os/format.os
- uses: stefanzweifel/git-auto-commit-action@v5
with:

206
.github/workflows/os/format.os vendored Normal file
View File

@ -0,0 +1,206 @@
Процедура ОтформатироватьМодуль(Знач ПутьКМодулю) Экспорт
ТекстовыйДокумент = Новый ТекстовыйДокумент();
ТекстовыйДокумент.Прочитать(ПутьКМодулю, "UTF-8");
БлокиКода = РазобратьМодульНаБлоки(ТекстовыйДокумент);
Для Н = 0 По БлокиКода.ВГраница() Цикл
МассивСтрокБлока = СтрРазделить(БлокиКода[Н], Символы.ПС);
Если МассивСтрокБлока.Количество() < 2 Тогда
Продолжить;
ИначеЕсли СтрНачинаетсяС(СокрЛП(МассивСтрокБлока[1]), "//") Тогда
Продолжить;
Иначе
ВыровнятьЗнакиРавно(МассивСтрокБлока);
ВыровнятьЗапятые(МассивСтрокБлока);
КонецЕсли;
БлокиКода[Н] = СтрСоединить(МассивСтрокБлока, Символы.ПС);
КонецЦикла;
ТекстФайла = СтрСоединить(БлокиКода, "");
ТекстовыйДокумент.УстановитьТекст(ТекстФайла);
ТекстовыйДокумент.Записать(ПутьКМодулю);
КонецПроцедуры
Функция РазобратьМодульНаБлоки(Знач ТекстовыйДокумент)
Для Н = 1 По ТекстовыйДокумент.КоличествоСтрок() Цикл
ТекущаяСтрока = ТекстовыйДокумент.ПолучитьСтроку(Н);
Если Не ЗначениеЗаполнено(СокрЛП(ТекущаяСтрока)) Тогда
ТекстовыйДокумент.ЗаменитьСтроку(Н, "⣿");
Иначе
ТекстовыйДокумент.ЗаменитьСтроку(Н, СокрП(ТекущаяСтрока));
КонецЕсли;
КонецЦикла;
ТекстФайла = ТекстовыйДокумент.ПолучитьТекст();
БлокиФайла = СтрРазделить(ТекстФайла, "⣿");
Возврат БлокиФайла;
КонецФункции
Процедура ВыровнятьЗнакиРавно(МассивСтрокБлока)
СоответствиеРасположений = Новый Соответствие();
МаксимальноеРасположение = 0;
ЧислоЗнаковРавно = 0;
Для Н = 0 По МассивСтрокБлока.ВГраница() Цикл
РасположениеРавно = СтрНайти(МассивСтрокБлока[Н], "=");
СоответствиеРасположений.Вставить(Н, РасположениеРавно);
МаксимальноеРасположение = ?(РасположениеРавно > МаксимальноеРасположение, РасположениеРавно, МаксимальноеРасположение);
Если Не РасположениеРавно = 0 Тогда
ЧислоЗнаковРавно = ЧислоЗнаковРавно + 1;
КонецЕсли;
КонецЦикла;
Если МаксимальноеРасположение = 0 Или ЧислоЗнаковРавно < 2 Тогда
Возврат;
КонецЕсли;
Для Каждого СтрокаБлока Из СоответствиеРасположений Цикл
РасположениеРавно = СтрокаБлока.Значение;
Индекс = СтрокаБлока.Ключ;
Если РасположениеРавно = 0 Или МаксимальноеРасположение - РасположениеРавно > 12 Тогда
Продолжить;
КонецЕсли;
Для Н = РасположениеРавно По МаксимальноеРасположение - 1 Цикл
МассивСтрокБлока[Индекс] = СтрЗаменить(МассивСтрокБлока[Индекс], "=", " =");
КонецЦикла;
КонецЦикла;
КонецПроцедуры
Процедура ВыровнятьЗапятые(МассивСтрокБлока, СоответствиеМаксимумов = "")
ПолноеСоответствиеРасположений = Новый Соответствие();
СтрокаСЗапятыми = 0;
НачалоСтроки = "";
Для Н = 0 По МассивСтрокБлока.ВГраница() Цикл
МассивУчастков = СтрРазделить(МассивСтрокБлока[Н], ",");
МассивУчастков_ = Новый Массив;
Соединение = Ложь;
СтрокаСоединения = "";
Для Каждого Участок Из МассивУчастков Цикл
ЧислоКавычек = СтрЧислоВхождений(Участок, """");
Если (ЧислоКавычек = 0 Или ЧислоКавычек % 2 = 0 ) И Не Соединение Тогда
МассивУчастков_.Добавить(Участок);
ИначеЕсли Соединение И ЧислоКавычек % 2 <> 0 Тогда
МассивУчастков_.Добавить(СтрокаСоединения + "," + Участок);
СтрокаСоединения = "";
Соединение = Ложь;
Иначе
СтрокаСоединения = ?(ЗначениеЗаполнено(СтрокаСоединения), СтрокаСоединения + "," + Участок, Участок);
Соединение = Истина;
КонецЕсли;
КонецЦикла;
МассивУчастков = МассивУчастков_;
Если МассивУчастков.Количество() < 2 Тогда
Продолжить;
Иначе
СтрокаСЗапятыми = СтрокаСЗапятыми + 1;
КонецЕсли;
МассивНачалаСтроки = СтрРазделить(МассивУчастков[0], "(");
Если МассивНачалаСтроки.Количество() < 2 Тогда
Продолжить;
КонецЕсли;
НачалоСтроки = МассивНачалаСтроки[0];
СоответствиеРасположений = ПолноеСоответствиеРасположений[НачалоСтроки];
Если Не ЗначениеЗаполнено(СоответствиеРасположений) Тогда
СоответствиеРасположений = Новый Соответствие;
КонецЕсли;
Для Р = 0 По МассивУчастков.ВГраница() - 1 Цикл
Если Не ЗначениеЗаполнено(СоответствиеМаксимумов) Тогда
ДлинаУчастка = СтрДлина(МассивУчастков[Р]);
ТекущийМаксимум = СоответствиеРасположений.Получить(Р);
ТекущийМаксимум = ?(ЗначениеЗаполнено(ТекущийМаксимум), ТекущийМаксимум, 0);
ТекущийМаксимум = ?(ДлинаУчастка > ТекущийМаксимум , ДлинаУчастка , ТекущийМаксимум);
СоответствиеРасположений.Вставить(Р, ТекущийМаксимум);
Иначе
ТекущееСоответствиеМаксимумов = СоответствиеМаксимумов[НачалоСтроки];
Если Не ЗначениеЗаполнено(ТекущееСоответствиеМаксимумов) Тогда
Прервать;
КонецЕсли;
НеобходимаяДлина = ТекущееСоответствиеМаксимумов[Р];
Если НеобходимаяДлина = Неопределено Тогда
Продолжить;
КонецЕсли;
Пока СтрДлина(МассивУчастков[Р]) < НеобходимаяДлина Цикл
МассивУчастков[Р] = МассивУчастков[Р] + " ";
КонецЦикла;
КонецЕсли;
КонецЦикла;
ПолноеСоответствиеРасположений.Вставить(НачалоСтроки, СоответствиеРасположений);
МассивСтрокБлока[Н] = СтрСоединить(МассивУчастков, ",");
КонецЦикла;
Если Не ЗначениеЗаполнено(СоответствиеМаксимумов)
И ЗначениеЗаполнено(ПолноеСоответствиеРасположений)
И СтрокаСЗапятыми > 1 Тогда
ВыровнятьЗапятые(МассивСтрокБлока, ПолноеСоответствиеРасположений);
КонецЕсли;
КонецПроцедуры
Для Каждого Файл Из НайтиФайлы("./src", "*.os", Истина) Цикл
Если СтрНайти(Файл.ПолноеИмя, "\cli\") = 0
И СтрНайти(Файл.ПолноеИмя, "/cli/") = 0 Тогда
ОтформатироватьМодуль(Файл.ПолноеИмя);
КонецЕсли;
КонецЦикла;
Для Каждого Файл Из НайтиФайлы("./src", "*.bsl", Истина) Цикл
Если СтрНайти(Файл.ПолноеИмя, "\cli\") = 0
И СтрНайти(Файл.ПолноеИмя, "/cli/") = 0 Тогда
ОтформатироватьМодуль(Файл.ПолноеИмя);
КонецЕсли;
КонецЦикла;

426
src/en/OInt/core/Modules/OPI_Airtable.os
View File

@ -42,91 +42,91 @@
// Get list of bases
// Gets the list of available bases
//
//
// Parameters:
// Token - String - Token - token
// Indent - String - Next page identifier of the base list from the previous request - offset
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
// Map Of KeyAndValue - serialized JSON response from Airtable
Function GetListOfBases(Val Token, Val Indent = "") Export
OPI_TypeConversion.GetLine(Indent);
URL = "https://api.airtable.com/v0/meta/bases";
Headers = GetAuthorizationHeader(Token);
URL = "https://api.airtable.com/v0/meta/bases";
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure;
OPI_Tools.AddField("offset", Indent, "String", Parameters);
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Get base tables
// Gets the schema of base tables
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Base identifier - base
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function GetDatabaseTables(Val Token, Val Base) Export
OPI_TypeConversion.GetLine(Base);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables";
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables";
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Create base
// Creates a new database
//
//
// Parameters:
// Token - String - Token - token
// Workspace - String - Workspace identifier - ws
// Name - String - New base name - title
// TableCollection - Map Of KeyAndValue - Table description: Key > name, Value > array of fields - tablesdata
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function CreateDatabase(Val Token, Val Workspace, Val Name, Val TableCollection) Export
OPI_TypeConversion.GetCollection(TableCollection);
If Not TypeOf(TableCollection) = Type("Structure")
If Not TypeOf(TableCollection) = Type("Structure")
And Not TypeOf(TableCollection) = Type("Map") Then
Raise "Error in table collection data";
EndIf;
URL = "https://api.airtable.com/v0/meta/bases";
Headers = GetAuthorizationHeader(Token);
URL = "https://api.airtable.com/v0/meta/bases";
Headers = GetAuthorizationHeader(Token);
TableArray = New Array;
For Each Table In TableCollection Do
Description = GenerateTableDescription(Table.Key, Table.Value);
TableArray.Add(Description);
EndDo;
Parameters = New Structure;
OPI_Tools.AddField("name" , Name , "String", Parameters);
OPI_Tools.AddField("tables" , TableArray , "Array", Parameters);
OPI_Tools.AddField("workspaceId", Workspace, "String", Parameters);
OPI_Tools.AddField("name" , Name , "String", Parameters);
OPI_Tools.AddField("tables" , TableArray , "Array" , Parameters);
OPI_Tools.AddField("workspaceId", Workspace , "String", Parameters);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
@ -137,56 +137,56 @@ EndFunction
// Create table
// Creates a new table in the base
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Base identifier - base
// Name - String - New table name - title
// FieldArray - Array of Structure - Array of field descriptions - fieldsdata
// Description - String - Table description - description
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function CreateTable(Val Token, Val Base, Val Name, Val FieldArray, Val Description = "") Export
OPI_TypeConversion.GetLine(Base);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables";
Headers = GetAuthorizationHeader(Token);
Parameters = GenerateTableDescription(Name, FieldArray, Description);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables";
Headers = GetAuthorizationHeader(Token);
Parameters = GenerateTableDescription(Name, FieldArray, Description);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Modify table
// Changes the name and/or description of the base
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Base identifier - base
// Table - String - Table identifier - table
// Name - String - New name - title
// Description - String - New description - description
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function ModifyTable(Val Token, Val Base, Val Table, Val Name = "", Val Description = "") Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables/" + Table;
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure;
OPI_Tools.AddField("name" , Name, "String", Parameters);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables/" + Table;
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure;
OPI_Tools.AddField("name" , Name , "String", Parameters);
OPI_Tools.AddField("description", Description , "String", Parameters);
Response = OPI_Tools.Patch(URL, Parameters, Headers);
Return Response;
EndFunction
@ -197,40 +197,40 @@ EndFunction
// Create field
// Creates a new field in the table
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Base identifier - base
// Table - String - Table identifier - table
// FieldStructure - Structure of KeyAndValue - Description of the new field - fielddata
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function CreateField(Val Token, Val Base, Val Table, Val FieldStructure) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetCollection(FieldStructure);
If Not TypeOf(FieldStructure) = Type("Structure")
If Not TypeOf(FieldStructure) = Type("Structure")
And Not TypeOf(FieldStructure) = Type("Map") Then
Raise "Error in field description data";
EndIf;
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables/" + Table + "/fields";
Headers = GetAuthorizationHeader(Token);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables/" + Table + "/fields";
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Post(URL, FieldStructure, Headers);
Return Response;
EndFunction
// Modify field
// Changes the name and/or description of an existing table field
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Base identifier Base - base
@ -238,152 +238,152 @@ EndFunction
// Field - String - Field identifier - field
// Name - String - New name - title
// Description - String - New description - description
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function ModifyField(Val Token, Val Base, Val Table, Val Field, Val Name = "", Val Description = "") Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Field);
URL = "https://api.airtable.com/v0/meta/bases/"
+ Base
+ "/tables/"
+ Table
+ "/fields/"
URL = "https://api.airtable.com/v0/meta/bases/"
+ Base
+ "/tables/"
+ Table
+ "/fields/"
+ Field;
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure();
OPI_Tools.AddField("name" , Name, "String", Parameters);
OPI_Tools.AddField("name" , Name , "String", Parameters);
OPI_Tools.AddField("description", Description , "String", Parameters);
Response = OPI_Tools.Patch(URL, Parameters, Headers);
Return Response;
EndFunction
// Get field (string)
// Gets the description of a string field
//
//
// Parameters:
// Name - String - New field name - title
//
//
// Returns:
// Structure - Field description
Function GetStringField(Val Name) Export
Return PrimitiveFieldDescription(Name, "richText");
EndFunction
// Get field (numeric)
// Gets the description of a numeric field
//
//
// Parameters:
// Name - String - New field name - title
// Precision - Number, String - Number of decimal places - precision
//
//
// Returns:
// Structure - Field description
Function GetNumberField(Val Name, Val Precision = 0) Export
OPI_TypeConversion.GetNumber(Precision);
OptionsStructure = New Structure("precision", Precision);
Return PrimitiveFieldDescription(Name, "number", OptionsStructure);
EndFunction
// Get field (file)
// Gets the description of a file field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetAttachmentField(Val Name) Export
Return PrimitiveFieldDescription(Name, "multipleAttachments");
EndFunction
// Get field (checkbox)
// Gets the description of a boolean field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetCheckboxField(Val Name) Export
OptionsStructure = New Structure("icon,color", "check", "yellowBright");
Return PrimitiveFieldDescription(Name, "checkbox", OptionsStructure);
EndFunction
// Get field (date)
// Gets the description of a date field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetDateField(Val Name) Export
FormatStructure = New Structure("format,name", "YYYY-MM-DD", "iso");
FormatStructure = New Structure("format,name", "YYYY-MM-DD", "iso");
OptionsStructure = New Structure("dateFormat", FormatStructure);
Return PrimitiveFieldDescription(Name, "date", OptionsStructure);
EndFunction
// Get field (email)
// Gets the description of an email field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetEmailField(Val Name) Export
Return PrimitiveFieldDescription(Name, "email");
EndFunction
// Get field (phone)
// Gets the description of a phone number field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetPhoneField(Val Name) Export
Return PrimitiveFieldDescription(Name, "phoneNumber");
EndFunction
// Get field (url)
// Gets the description of a URL field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetLinkField(Val Name) Export
Return PrimitiveFieldDescription(Name, "url");
EndFunction
#EndRegion
@ -392,67 +392,67 @@ EndFunction
// Get list of records
// Gets the list of records of the selected table
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Indent - String - Next page identifier of data from the previous request - offset
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function GetListOfRecords(Val Token, Val Base, Val Table, Val Indent = "") Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table;
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure();
OPI_Tools.AddField("offset", Indent, "String", Parameters);
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Get record
// Gets row data of the table by identifier
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Record - String - Record identifier in the table - record
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function GetRecord(Val Token, Val Base, Val Table, Val Record) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Record);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record;
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Create records
// Creates one or an array of records by description or an array of field value descriptions
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Data - Structure, Array of Structure - Set or array of sets of pairs Key : Value > Field : FieldValue - data
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function CreatePosts(Val Token, Val Base, Val Table, Val Data) Export
@ -460,52 +460,52 @@ Function CreatePosts(Val Token, Val Base, Val Table, Val Data) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetCollection(Data);
Parameters = New Structure();
AddDataDescription(Data, Parameters);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table;
Parameters = New Structure();
AddDataDescription(Data, Parameters);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table;
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
Return Response;
EndFunction
// Delete records
// Deletes one or an array of records by identifiers
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Records - String, Array of String - Identifier or array of record identifiers - records
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function DeletePosts(Val Token, Val Base, Val Table, Val Records) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetArray(Records);
RecordString = "";
For Each Record In Records Do
RecordString = RecordString
RecordString = RecordString
+ ?(ValueIsFilled(RecordString), "&", "?")
+ "records[]="
+ OPI_Tools.NumberToString(Record);
+ OPI_Tools.NumberToString(Record);
EndDo;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + RecordString;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + RecordString;
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
Return Response;
EndFunction
#EndRegion
@ -514,67 +514,67 @@ EndFunction
// Get comments
// Gets the list of comments for a record in the table
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Record - String - Record identifier in the table - record
// Indent - String - Next page identifier of data from the previous request - offset
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function GetComments(Val Token, Val Base, Val Table, Val Record, Val Indent = "") Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Record);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments";
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments";
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure();
OPI_Tools.AddField("offset", Indent, "String", Parameters);
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Create comment
// Creates a comment for a record in the table
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Record - String - Record identifier in the table - record
// Text - String - Comment text - text
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function CreateComment(Val Token, Val Base, Val Table, Val Record, Val Text) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Record);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments";
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments";
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure();
OPI_Tools.AddField("text", Text, "String", Parameters);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Modify comment
// Changes the text of an existing comment
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
@ -582,54 +582,54 @@ EndFunction
// Record - String - Record identifier in the table - record
// Comment - String - Comment identifier - comment
// Text - String - New comment text - text
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function EditComment(Val Token, Val Base, Val Table, Val Record, Val Comment, Val Text) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Record);
OPI_TypeConversion.GetLine(Comment);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments/" + Comment;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments/" + Comment;
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure();
OPI_Tools.AddField("text", Text, "String", Parameters);
Response = OPI_Tools.Patch(URL, Parameters, Headers);
Return Response;
EndFunction
// Delete comment
// Deletes a comment for a table record
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Record - String - Record identifier in the table - record
// Comment - String - Comment identifier - comment
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
// Map Of KeyAndValue - serialized JSON response from Airtable
Function DeleteComment(Val Token, Val Base, Val Table, Val Record, Val Comment) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Record);
OPI_TypeConversion.GetLine(Comment);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments/" + Comment;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments/" + Comment;
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
#EndRegion
@ -639,58 +639,58 @@ EndFunction
#Region Private
Function GetAuthorizationHeader(Val Token)
OPI_TypeConversion.GetLine(Token);
Headers = New Map;
Headers.Insert("Authorization", "Bearer " + Token);
Return Headers;
EndFunction
Function GenerateTableDescription(Val Name, Val FieldArray, Val Description = "")
OPI_TypeConversion.GetLine(Name);
OPI_TypeConversion.GetCollection(FieldArray);
TableDescription = New Structure("name,fields", Name, FieldArray);
OPI_Tools.AddField("description", Description, "String", TableDescription);
Return TableDescription;
EndFunction
Function PrimitiveFieldDescription(Val Name, Val Type, Val Options = "")
FieldStructure = New Structure();
OPI_Tools.AddField("name" , Name, "String" , FieldStructure);
OPI_Tools.AddField("type" , Type , "String" , FieldStructure);
OPI_Tools.AddField("name" , Name , "String" , FieldStructure);
OPI_Tools.AddField("type" , Type , "String" , FieldStructure);
OPI_Tools.AddField("options", Options , "Collection", FieldStructure);
Return FieldStructure;
EndFunction
Procedure AddDataDescription(Val Data, Parameters)
If TypeOf(Data) = Type("Array") Then
SendArray = New Array;
For Each RecordDescription In Data Do
SendArray.Add(New Structure("fields", RecordDescription));
SendArray.Add(New Structure("fields", RecordDescription));
EndDo;
OPI_Tools.AddField("records", SendArray, "Array", Parameters);
Else
OPI_Tools.AddField("fields", Data, "Collection", Parameters);
OPI_Tools.AddField("fields", Data, "Collection", Parameters);
EndIf;
EndProcedure
#EndRegion

2312
src/en/OInt/core/Modules/OPI_Bitrix24.os
View File

File diff suppressed because it is too large Load Diff

668
src/en/OInt/core/Modules/OPI_Dropbox.os
View File

File diff suppressed because it is too large Load Diff

420
src/en/OInt/core/Modules/OPI_GoogleCalendar.os
View File

@ -43,131 +43,131 @@
// Create calendar
// Creates an empty calendar
//
//
// Parameters:
// Token - String - Token - token
// Name - String - Name of the created calendar - title
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CreateCalendar(Val Token, Val Name) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Name);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars";
URL = "https://www.googleapis.com/calendar/v3/calendars";
Parameters = New Structure;
Parameters.Insert("summary" , Name);
Parameters.Insert("timeZone", "Europe/Moscow");
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Get calendar
// Gets calendar information by ID
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetCalendarMetadata(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Edit calendar
// Edits properties of an existing calendar
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// Name - String - New name - title
// Description - String - New calendar description - description
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function EditCalendarMetadata(Val Token
, Val Calendar
, Val Name = ""
, Val Description = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
OPI_TypeConversion.GetLine(Name);
OPI_TypeConversion.GetLine(Description);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
Parameters = New Structure;
If ValueIsFilled(Name) Then
Parameters.Insert("summary", Name);
EndIf;
If ValueIsFilled(Description) Then
Parameters.Insert("description", Description);
EndIf;
Response = OPI_Tools.Patch(URL, Parameters, Headers, True);
Return Response;
EndFunction
// Clear primary calendar
// Clears the event list of the primary calendar
//
//
// Parameters:
// Token - String - Token - token
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function ClearMainCalendar(Val Token) Export
OPI_TypeConversion.GetLine(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/primary/clear";
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/primary/clear";
Response = OPI_Tools.Post(URL, , Headers, False);
Return Response;
EndFunction
// Delete calendar
// Deletes a calendar by ID
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteCalendar(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
@ -178,105 +178,105 @@ EndFunction
// Get list of calendars
// Gets an array of account calendars
//
//
// Parameters:
// Token - String - Token - token
//
//
// Returns:
// Map Of KeyAndValue - Array of calendar data mappings
Function GetCalendarList(Val Token) Export
OPI_TypeConversion.GetLine(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
ArrayOfCalendars = New Array;
GetCalendarsListRecursively(Headers, ArrayOfCalendars);
Return ArrayOfCalendars;
EndFunction
// Add calendar to list
// Adds an existing calendar to the user's list
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function AddCalendarToList(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList";
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList";
Parameters = New Structure;
Parameters.Insert("id", Calendar);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Get list calendar
// Gets a calendar from the user's list by ID
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetListCalendar(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar;
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Remove calendar from list
// Removes a calendar from the user's list
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteCalendarFromList(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar;
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
// Edit list calendar
// Edits the properties of a calendar from the user's list
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// PrimaryColor - String - HEX primary color (#ffffff) - primary
// SecondaryColor - String - HEX secondary color (#ffffff) - secondary
// Hidden - Boolean - Hidden calendar - hidden
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function EditListCalendar(Val Token
@ -284,23 +284,23 @@ Function EditListCalendar(Val Token
, Val PrimaryColor
, Val SecondaryColor
, Val Hidden = False) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
OPI_TypeConversion.GetLine(PrimaryColor);
OPI_TypeConversion.GetLine(SecondaryColor);
OPI_TypeConversion.GetBoolean(Hidden);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar + "?colorRgbFormat=true";
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar + "?colorRgbFormat =true";
Parameters = New Map;
Parameters.Insert("hidden" , Hidden);
Parameters.Insert("hidden" , Hidden);
Parameters.Insert("foregroundColor", PrimaryColor);
Parameters.Insert("backgroundColor", SecondaryColor);
Response = OPI_Tools.Put(URL, Parameters, Headers);
Return Response;
EndFunction
@ -310,167 +310,167 @@ EndFunction
#Region EventManagement
// Get event description !NOCLI
//
//
// Returns:
// Map Of KeyAndValue - Empty event template
Function GetEventDescription() Export
CurrentDate = OPI_Tools.GetCurrentDate();
Hour = 3600;
Event = New Map;
Event.Insert("Description" , ""); // Event description
Event.Insert("Title" , "New event"); // Title events
Event.Insert("Venue" , ""); // String description of the venue of the event
Event.Insert("StartDate" , CurrentDate); // Date of start events
Event.Insert("EndDate" , CurrentDate + Hour); // Date of end events
Hour = 3600;
Event = New Map;
Event.Insert("Description" , ""); // Event description
Event.Insert("Title" , "New event"); // Title events
Event.Insert("Venue" , ""); // String description of the venue of the event
Event.Insert("StartDate" , CurrentDate); // Date of start events
Event.Insert("EndDate" , CurrentDate + Hour); // Date of end events
Event.Insert("ArrayOfAttachmentURLs", New Map); // Key - name, Value - URL to file
Event.Insert("SendNotifications" , True); // Indication of sending notifications to participants
Event.Insert("SendNotifications" , True); // Indication of sending notifications to participants
Return Event;
EndFunction
// Get list of events
// Gets the list of all calendar events
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - Array of event maps
Function GetEventList(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
ArrayOfEvents = New Array;
GetEventsListRecursively(Headers, Calendar, ArrayOfEvents);
Return ArrayOfEvents;
EndFunction
// Get event
// Gets an event by ID
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// Event - String - Event ID - event
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetEvent(Val Token, Val Calendar, Val Event) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
OPI_TypeConversion.GetLine(Event);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
+ "/events/"
+ Event;
+ Event;
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Create event
// Creates a new event
//
//
// Parameters:
// Token - String - Token - token
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// EventDescription - Map Of KeyAndValue - Event description - props
//
//
// Returns:
// String, Arbitrary, HTTPResponse, BinaryData, Undefined - Google server response
Function CreateEvent(Val Token, Val Calendar, Val EventDescription) Export
Function CreateEvent(Val Token, Val Calendar, Val EventDescription) Export
Return EventManagement(Token, Calendar, EventDescription);
EndFunction
// Move event
// Moves an event to another calendar
//
//
// Parameters:
// Token - String - Token - token
// SourceCalendar - String - ID of the source calendar - from
// TargetCalendar - String - ID of the target calendar - to
// Event - String - ID of the source calendar event - event
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function MoveEvent(Val Token, Val SourceCalendar, Val TargetCalendar, Val Event) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(SourceCalendar);
OPI_TypeConversion.GetLine(TargetCalendar);
OPI_TypeConversion.GetLine(Event);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ SourceCalendar
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ SourceCalendar
+ "/events/"
+ Event
+ "/move?destination="
+ TargetCalendar;
+ TargetCalendar;
Response = OPI_Tools.Post(URL, , Headers);
Return Response;
EndFunction
// Edit event
// Edits an existing event
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// EventDescription - String - New event description - props
// Event - String - Event ID - event
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function EditEvent(Val Token, Val Calendar, Val EventDescription, Val Event) Export
Return EventManagement(Token, Calendar, EventDescription, Event);
EndFunction
// Delete event
// Deletes an event by ID
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// Event - String - Event ID - event
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteEvent(Val Token, Val Calendar, Val Event) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
OPI_TypeConversion.GetLine(Event);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
+ "/events/"
+ Event;
+ Event;
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
@ -482,51 +482,51 @@ EndFunction
#Region Private
Function ConvertDate(Val Date)
OPI_TypeConversion.GetDate(Date);
DateStructure = New Structure;
If Not TypeOf(Date) = Type("Date") Then
Return Undefined;
EndIf;
If Date = BegOfDay(Date) Then
If Date = BegOfDay(Date) Then
DateFormat = "DF=yyyy-MM-dd";
Field = "date";
Field = "date";
Else
DateFormat = "DF=yyyy-MM-ddTHH:mm:ssZ";
Field = "dateTime";
Field = "dateTime";
EndIf;
Date = Format(Date, DateFormat);
DateStructure.Insert(Field , Date);
DateStructure.Insert(Field , Date);
DateStructure.Insert("timeZone", "Europe/Moscow");
Return DateStructure;
EndFunction
Function ConvertAttachments(Val Attachments)
OPI_TypeConversion.GetCollection(Attachments);
AttachmentsArray = New Array;
If TypeOf(Attachments) = Type("Map") Or TypeOf(Attachments) = Type("Structure") Then
For Each Attachment In Attachments Do
CurrentAttachment = New Structure;
CurrentAttachment.Insert("title" , Attachment.Key);
CurrentAttachment.Insert("title" , Attachment.Key);
CurrentAttachment.Insert("fileUrl", Attachment.Value);
AttachmentsArray.Add(CurrentAttachment);
EndDo;
EndIf;
If AttachmentsArray.Count() > 0 Then
Return AttachmentsArray;
Else
@ -536,105 +536,105 @@ Function ConvertAttachments(Val Attachments)
EndFunction
Function EventManagement(Val Token, Val Calendar, Val EventDescription, Val Event = "")
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
OPI_TypeConversion.GetLine(Event);
OPI_TypeConversion.GetCollection(EventDescription);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Existing = ValueIsFilled(Event);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
+ "/events"
+ ?(Existing, "/" + Event, "");
Date0 = EventDescription["StartDate"];
Date1 = EventDescription["EndDate"];
Attachments = EventDescription["ArrayOfAttachmentURLs"];
Attachments = ConvertAttachments(Attachments);
+ ?(Existing, "/" + Event, "");
Date0 = EventDescription["StartDate"];
Date1 = EventDescription["EndDate"];
Attachments = EventDescription["ArrayOfAttachmentURLs"];
Attachments = ConvertAttachments(Attachments);
Notifications = ?(EventDescription["SendNotifications"] = Undefined
, False
, EventDescription["SendNotifications"]);
Parameters = New Structure;
Parameters.Insert("summary" , EventDescription["Title"]);
Parameters.Insert("summary" , EventDescription["Title"]);
Parameters.Insert("description", EventDescription["Description"]);
Parameters.Insert("location" , EventDescription["Venue"]);
Parameters.Insert("start" , ConvertDate(Date0));
Parameters.Insert("end" , ConvertDate(Date1));
Parameters.Insert("attachments", Attachments);
URLParameters = New Structure;
URLParameters.Insert("sendUpdates" , ?(Notifications, "all", "none"));
Parameters.Insert("location" , EventDescription["Venue"]);
Parameters.Insert("start" , ConvertDate(Date0));
Parameters.Insert("end" , ConvertDate(Date1));
Parameters.Insert("attachments", Attachments);
URLParameters = New Structure;
URLParameters.Insert("sendUpdates" , ?(Notifications , "all" , "none"));
URLParameters.Insert("supportsAttachments" , ?(ValueIsFilled(Attachments), "true", "false"));
URL = URL + OPI_Tools.RequestParametersToString(URLParameters);
OPI_Tools.RemoveEmptyCollectionFields(Parameters);
If Existing Then
Response = OPI_Tools.Patch(URL, Parameters, Headers, True);
Else
Response = OPI_Tools.Post(URL, Parameters, Headers, True);
EndIf;
Return Response;
EndFunction
Procedure GetCalendarsListRecursively(Val Headers, ArrayOfCalendars, Page = "")
Items = "items";
NPT = "nextPageToken";
Procedure GetCalendarsListRecursively(Val Headers, ArrayOfCalendars, Page = "")
Items = "items";
NPT = "nextPageToken";
Parameters = New Structure;
If ValueIsFilled(Page) Then
Parameters.Insert("pageToken", Page);
EndIf;
Result = OPI_Tools.Get("https://www.googleapis.com/calendar/v3/users/me/calendarList"
, Parameters
, Headers);
Calendars = Result[Items];
Page = Result[NPT];
Page = Result[NPT];
For Each Calendar In Calendars Do
ArrayOfCalendars.Add(Calendar);
EndDo;
ArrayOfCalendars.Add(Calendar);
EndDo;
If Calendars.Count() > 0 And ValueIsFilled(Page) Then
GetCalendarsListRecursively(Headers, ArrayOfCalendars, Page);
GetCalendarsListRecursively(Headers, ArrayOfCalendars, Page);
EndIf;
EndProcedure
Procedure GetEventsListRecursively(Val Headers, Val Calendar, ArrayOfEvents, Page = "")
Items = "items";
NPT = "nextPageToken";
Procedure GetEventsListRecursively(Val Headers, Val Calendar, ArrayOfEvents, Page = "")
Items = "items";
NPT = "nextPageToken";
Parameters = New Structure;
If ValueIsFilled(Page) Then
Parameters.Insert("pageToken", Page);
EndIf;
Result = OPI_Tools.Get("https://www.googleapis.com/calendar/v3/calendars/" + Calendar + "/events"
, Parameters
, Headers);
Events = Result[Items];
Page = Result[NPT];
Page = Result[NPT];
For Each Event In Events Do
ArrayOfEvents.Add(Event);
EndDo;
ArrayOfEvents.Add(Event);
EndDo;
If Events.Count() > 0 And ValueIsFilled(Page) Then
GetEventsListRecursively(Headers, ArrayOfEvents, Page);
GetEventsListRecursively(Headers, ArrayOfEvents, Page);
EndIf;
EndProcedure
#EndRegion

502
src/en/OInt/core/Modules/OPI_GoogleDrive.os
View File

@ -43,277 +43,277 @@
// Get object information
// Gets information about a folder or file by ID
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Identifier of the file or folder - object
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetObjectInformation(Val Token, Val Identifier) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
Parameters = New Structure;
Parameters.Insert("fields", "*");
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Get list of directories
// Gets the list of drive directories
//
//
// Parameters:
// Token - String - Token - token
// NameContains - String - Filter by name - querry
// Detailed - Boolean - Adds a list of files to the directory fields - depth
//
//
// Returns:
// Map Of KeyAndValue - Array of directory mappings
Function GetDirectoriesList(Val Token, Val NameContains = "", Val Detailed = False) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(NameContains);
OPI_TypeConversion.GetBoolean(Detailed);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
ArrayOfObjects = New Array;
Filter = New Array;
Filter = New Array;
Filter.Add("mimeType = 'application/vnd.google-apps.folder'");
If ValueIsFilled(NameContains) Then
Filter.Add("name contains '" + NameContains + "'");
EndIf;
GetObjectsListRecursively(Headers, ArrayOfObjects, Detailed, Filter);
If Detailed Then
BreakDownObjectsInDetail(Token, ArrayOfObjects);
BreakDownObjectsInDetail(Token, ArrayOfObjects);
EndIf;
Return ArrayOfObjects;
EndFunction
// Get list of files
// Gets the list of files
//
//
// Parameters:
// Token - String - Token - token
// NameContains - String - Filter by name - querry
// Directory - String - Filter by parent directory ID - catalog
//
//
// Returns:
// Map Of KeyAndValue - Array of file mappings
Function GetFilesList(Val Token, Val NameContains = "", Val Directory = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(NameContains);
OPI_TypeConversion.GetLine(Directory);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
ArrayOfObjects = New Array;
Filter = New Array;
Filter = New Array;
Filter.Add("mimeType != 'application/vnd.google-apps.folder'");
If ValueIsFilled(NameContains) Then
Filter.Add("name contains '" + NameContains + "'");
EndIf;
If ValueIsFilled(Directory) Then
Filter.Add("'" + Directory + "' in parents");
EndIf;
GetObjectsListRecursively(Headers, ArrayOfObjects, , Filter);
Return ArrayOfObjects;
EndFunction
// Upload file
// Uploads a file to the drive
//
//
// Parameters:
// Token - String - Token - token
// File - BinaryData,String - File to be uploaded - file
// Description - Map Of KeyAndValue - See GetFileDescription - props - JSON description or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function UploadFile(Val Token, Val File, Val Description) Export
Return FileManagement(Token, File, Description);
Return FileManagement(Token, File, Description);
EndFunction
// Create folder
// Creates an empty directory on the drive
//
//
// Parameters:
// Token - String - Token - token
// Name - String - Folder name - title
// Parent - String - Parent - catalog
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CreateFolder(Val Token, Val Name, Val Parent = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Name);
OPI_TypeConversion.GetLine(Parent);
Description = New Map;
Description.Insert("MIME" , "application/vnd.google-apps.folder");
Description.Insert("Name" , Name);
Description.Insert("MIME" , "application/vnd.google-apps.folder");
Description.Insert("Name" , Name);
Description.Insert("Description", "");
Description.Insert("Parent", ?(ValueIsFilled(Parent), Parent, "root"));
Description.Insert("Parent" , ?(ValueIsFilled(Parent), Parent, "root"));
Return FileManagement(Token, , Description);
EndFunction
// Download file
// Gets file by ID
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - File identifier - object
// SavePath - String - File save path - out
//
// SavePath - String - File save path - out
//
// Returns:
// BinaryData,String - Binary data or file path when SavePath parameter is specified
Function DownloadFile(Val Token, Val Identifier, Val SavePath = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
Parameters = New Map;
Parameters.Insert("alt", "media");
Response = OPI_Tools.Get(URL, Parameters , Headers, SavePath);
Return Response;
EndFunction
// Copy object
// Copies file or directory
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Object identifier - object
// NewName - String - New object name - title
// NewParent - String - New parent directory - catalog
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CopyObject(Val Token, Val Identifier, Val NewName = "", Val NewParent = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(NewName);
OPI_TypeConversion.GetLine(Identifier);
OPI_TypeConversion.GetLine(NewParent);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier + "/copy";
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier + "/copy";
Parameters = New Structure;
If ValueIsFilled(NewName) Then
Parameters.Insert("name", NewName);
EndIf;
If ValueIsFilled(NewParent) Then
ArrayOfParents = New Array;
ArrayOfParents.Add(NewParent);
Parameters.Insert("parents", ArrayOfParents);
EndIf;
Response = OPI_Tools.Post(URL, Parameters , Headers, True);
Return Response;
EndFunction
// Update file
// Updates file binary data
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Identifier of the object to update - object
// File - BinaryData,String - File source for update - file
// NewName - String - New file name (if necessary) - title
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function UpdateFile(Val Token, Val Identifier, Val File, Val NewName = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
OPI_TypeConversion.GetLine(NewName);
OPI_TypeConversion.GetBinaryData(File);
If ValueIsFilled(NewName) Then
Description = New Map;
Description.Insert("Name", NewName);
Else
Description = "";
EndIf;
Return FileManagement(Token, File, Description, Identifier);
EndFunction
// Delete object
// Deletes file or directory by ID
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Identifier of the object to delete - object
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteObject(Val Token, Val Identifier) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
// Get file description !NOCLI
//
//
// Returns:
// Map Of KeyAndValue - File description
Function GetFileDescription() Export
Description = New Map;
Description.Insert("MIME" , "image/jpeg"); // MIME-type uploading file
Description.Insert("Name" , "New file.jpg"); // File name with extension
Description.Insert("MIME" , "image/jpeg"); // MIME-type uploading file
Description.Insert("Name" , "New file.jpg"); // File name with extension
Description.Insert("Description" , "This is a new file"); // File description
Description.Insert("Parent" , "root"); // ID directory upload or "root" for upload in root
Description.Insert("Parent" , "root"); // ID directory upload or "root" for upload in root
Return Description;
EndFunction
#EndRegion
@ -322,107 +322,107 @@ EndFunction
// Create comment
// Creates a comment for a file or directory
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Identifier of the object that needs a comment - object
// Identifier - String - Identifier of the object that needs a comment - object
// Comment - String - Comment text - text
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CreateComment(Val Token, Val Identifier, Val Comment) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
OPI_TypeConversion.GetLine(Comment);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier + "/comments?fields=*";
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier + "/comments?fields =*";
Parameters = New Structure;
Parameters.Insert("content", Comment);
Response = OPI_Tools.POST(URL, Parameters, Headers);
Return Response;
EndFunction
// Get comment
// Gets comment by ID
//
//
// Parameters:
// Token - String - Token - token
// ObjectID - String - Identifier of the file or directory where the comment is located - object
// CommentID - String - Comment identifier - comment
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetComment(Val Token, Val ObjectID, Val CommentID) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(ObjectID);
OPI_TypeConversion.GetLine(CommentID);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments/" + CommentID;
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments/" + CommentID;
Parameters = New Structure;
Parameters.Insert("fields", "*");
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Get list of comments
// Gets the list of all comments of the object
//
//
// Parameters:
// Token - String - Token - token
// ObjectID - String - Object identifier - object
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetCommentList(Val Token, Val ObjectID) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(ObjectID);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments";
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments";
Parameters = New Structure;
Parameters.Insert("fields", "*");
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Delete comment
// Deletes comment by ID
//
//
// Parameters:
// Token - String - Token - token
// ObjectID - String - Identifier of the file or directory where the comment is located - object
// CommentID - String - Comment identifier - comment
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteComment(Val Token, Val ObjectID, Val CommentID) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(ObjectID);
OPI_TypeConversion.GetLine(CommentID);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments/" + CommentID;
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments/" + CommentID;
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
@ -433,294 +433,294 @@ EndFunction
#Region Private
Procedure GetObjectsListRecursively(Val Headers, ArrayOfObjects, Detailed = False, Filter = "", Page = "")
URL = "https://www.googleapis.com/drive/v3/files";
Files = "files";
NPT = "nextPageToken";
Procedure GetObjectsListRecursively(Val Headers, ArrayOfObjects, Detailed = False, Filter = "", Page = "")
URL = "https://www.googleapis.com/drive/v3/files";
Files = "files";
NPT = "nextPageToken";
Parameters = New Structure;
Parameters.Insert("fields", "*");
If ValueIsFilled(Page) Then
Parameters.Insert("pageToken", Page);
EndIf;
If ValueIsFilled(Filter) And TypeOf(Filter) = Type("Array") Then
If ValueIsFilled(Filter) And TypeOf(Filter) = Type("Array") Then
FilterString = StrConcat(Filter, " and ");
Parameters.Insert("q", FilterString);
Parameters.Insert("q", FilterString);
EndIf;
Result = OPI_Tools.Get(URL, Parameters, Headers);
Objects = Result[Files];
Page = Result[NPT];
Page = Result[NPT];
For Each CurrentObject In Objects Do
ArrayOfObjects.Add(CurrentObject);
EndDo;
EndDo;
If Objects.Count() > 0 And ValueIsFilled(Page) Then
GetObjectsListRecursively(Headers, ArrayOfObjects, Detailed, Filter, Page);
GetObjectsListRecursively(Headers, ArrayOfObjects, Detailed, Filter, Page);
EndIf;
EndProcedure
Procedure BreakDownObjectsInDetail(Val Token, ArrayOfObjects)
Procedure BreakDownObjectsInDetail(Val Token, ArrayOfObjects)
For Each CurrentObject In ArrayOfObjects Do
ArrayOfFiles = New Array;
CurrentID = CurrentObject["id"];
CurrentID = CurrentObject["id"];
Result = GetFilesList(Token, , CurrentID);
For Each File In Result Do
ArrayOfFiles.Add(File);
ArrayOfFiles.Add(File);
EndDo;
CurrentObject.Insert("files", ArrayOfFiles);
EndDo;
EndProcedure
Procedure FormFileUploadParameters(Description)
FormedDescription = New Map;
OPI_Tools.RemoveEmptyCollectionFields(Description);
FieldMapping = New Map;
FieldMapping.Insert("MIME" , "mimeType");
FieldMapping.Insert("Name" , "name");
FieldMapping.Insert("MIME" , "mimeType");
FieldMapping.Insert("Name" , "name");
FieldMapping.Insert("Description" , "description");
FieldMapping.Insert("Parent" , "parents");
FieldMapping.Insert("Extension", "fileExtension");
FieldMapping.Insert("Parent" , "parents");
FieldMapping.Insert("Extension" , "fileExtension");
For Each Element In Description Do
If Element.Key = "Parent" Then
CurrentValue = New Array;
CurrentValue.Add(Element.Value);
Else
CurrentValue = Element.Value;
EndIf;
FieldName = FieldMapping.Get(Element.Key);
FormedDescription.Insert(FieldName, CurrentValue);
EndDo;
Description = FormedDescription;
EndProcedure
Function FileManagement(Val Token, Val File = "", Val Description = "", Val Identifier = "")
Function FileManagement(Val Token, Val File = "", Val Description = "", Val Identifier = "")
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
If ValueIsFilled(Description) Then
OPI_TypeConversion.GetCollection(Description);
EndIf;
MimeType = "mimeType";
If ValueIsFilled(Identifier) Then
MIME = GetObjectInformation(Token, Identifier)[MimeType];
Else
MIME = Description["MIME"];
EndIf;
EndIf;
If Not ValueIsFilled(Description) Then
Description = New Map;
EndIf;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
FormFileUploadParameters(Description);
JSONDescription = OPI_Tools.JSONString(Description);
FileMapping = New Map;
If ValueIsFilled(File) Then
ChunkSize = 268435457;
Size = OPI_Tools.ConvertDataWithSizeRetrieval(File, ChunkSize);
ChunkSize = 268435457;
Size = OPI_Tools.ConvertDataWithSizeRetrieval(File, ChunkSize);
FileMapping.Insert(File, MIME);
If Size < ChunkSize And TypeOf(File) = Type("BinaryData") Then
Response = UploadSmallFile(JSONDescription, FileMapping, Headers, Identifier);
Else
Response = UploadLargeFile(Description, FileMapping, Headers, Identifier);
EndIf;
Else
Response = UploadSmallFile(JSONDescription, FileMapping, Headers, Identifier);
Response = UploadSmallFile(JSONDescription, FileMapping, Headers, Identifier);
EndIf;
Return Response;
EndFunction
Function UploadSmallFile(Val Description, Val FileMapping, Val Headers, Val Identifier = "")
URL = "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart";
If ValueIsFilled(Identifier) Then
URL = StrReplace(URL, "/files", "/files/" + Identifier);
URL = StrReplace(URL, "/files", "/files/" + Identifier);
Response = OPI_Tools.PatchMultipartRelated(URL, Description, FileMapping, Headers);
Else
Response = OPI_Tools.PostMultipartRelated(URL, Description, FileMapping, Headers);
EndIf;
Return Response;
EndFunction
Function UploadLargeFile(Val Description, Val FileMapping, Val Headers, Val Identifier = "")
For Each File In FileMapping Do
Binary = File.Key;
Break;
EndDo;
URL = "https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable";
If ValueIsFilled(Identifier) Then
URL = StrReplace(URL, "/files", "/files/" + Identifier);
URL = StrReplace(URL, "/files", "/files/" + Identifier);
Response = OPI_Tools.Patch(URL, Description, Headers, True, True);
Else
Response = OPI_Tools.Post(URL, Description, Headers, True, True);
EndIf;
UploadURL = Response.Headers["Location"];
If Not ValueIsFilled(UploadURL) Then
OPI_Tools.ProcessResponse(Response);
Return Response;
EndIf;
UploadResponse = UploadFileInParts(Binary, UploadURL);
Response = ?(ValueIsFilled(UploadResponse), UploadResponse, Response);
Response = ?(ValueIsFilled(UploadResponse), UploadResponse, Response);
OPI_Tools.ProcessResponse(Response);
Return Response;
EndFunction
Function UploadFileInParts(Val Binary, Val UploadURL)
Response = "";
ChunkSize = 268435456;
BytesRead = 0;
Response = "";
ChunkSize = 268435456;
BytesRead = 0;
CurrentPosition = 0;
TotalSize = Binary.Size();
StrTotalSize = OPI_Tools.NumberToString(TotalSize);
DataReader = New DataReader(Binary);
SourceStream = DataReader.SourceStream();
TotalSize = Binary.Size();
StrTotalSize = OPI_Tools.NumberToString(TotalSize);
DataReader = New DataReader(Binary);
SourceStream = DataReader.SourceStream();
WHile BytesRead < TotalSize Do
BytesRead = SourceStream.CurrentPosition();
Result = DataReader.Read(ChunkSize);
CurrentData = Result.GetBinaryData();
CurrentSize = CurrentData.Size();
NextPosition = CurrentPosition + CurrentSize - 1;
BytesRead = SourceStream.CurrentPosition();
Result = DataReader.Read(ChunkSize);
CurrentData = Result.GetBinaryData();
CurrentSize = CurrentData.Size();
NextPosition = CurrentPosition + CurrentSize - 1;
If Not ValueIsFilled(CurrentData) Then
Break;
EndIf;
StreamHeader = "bytes "
+ OPI_Tools.NumberToString(CurrentPosition)
+ "-"
+ OPI_Tools.NumberToString(NextPosition)
+ "/"
+ "-"
+ OPI_Tools.NumberToString(NextPosition)
+ "/"
+ StrTotalSize;
AdditionalHeaders = New Map;
AdditionalHeaders.Insert("Content-Length", OPI_Tools.NumberToString(CurrentSize));
AdditionalHeaders.Insert("Content-Range" , StreamHeader);
AdditionalHeaders.Insert("Content-Type" , "application/octet-stream");
AdditionalHeaders.Insert("Content-Range" , StreamHeader);
AdditionalHeaders.Insert("Content-Type" , "application/octet-stream");
Response = OPI_Tools.Put(UploadURL, CurrentData, AdditionalHeaders, False, True);
CheckResult = CheckPartUpload(Response, StrTotalSize, AdditionalHeaders, UploadURL, CurrentPosition);
If ValueIsFilled(CheckResult) Then
Return CheckResult;
EndIf;
KBytes = 1024;
MByte = KBytes * KBytes;
MByte = KBytes * KBytes;
Message(OPI_Tools.ProgressInformation(CurrentPosition, TotalSize, "MB", MByte));
RunGarbageCollection();
FreeObject(CurrentData);
EndDo;
Return Response;
EndFunction
Function CheckPartUpload(Response, StrTotalSize, AdditionalHeaders, UploadURL, CurrentPosition)
StartOfErrorCodes = 400;
EndOfFailureCodes = 600;
StartOfErrorCodes = 400;
EndOfFailureCodes = 600;
StartOfSuccessCodes = 200;
EndOfSuccessCodes = 300;
Redirection = 308;
EndOfSuccessCodes = 300;
Redirection = 308;
If Response.StatusCode >= StartOfErrorCodes And Response.StatusCode < EndOfFailureCodes Then
StreamHeader = "bytes */" + StrTotalSize;
AdditionalHeaders.Insert("Content-Range" , StreamHeader);
CheckResponse = OPI_Tools.Put(UploadURL, "", AdditionalHeaders, False, True);
If CheckResponse.StatusCode >= StartOfSuccessCodes And CheckResponse.StatusCode < EndOfSuccessCodes Then
OPI_Tools.ProcessResponse(CheckResponse);
Return CheckResponse;
ElsIf CheckResponse.StatusCode = Redirection Then
UploadedData = Response.Headers["Range"];
Else
OPI_Tools.ProcessResponse(Response);
Return Response;
EndIf;
Else
UploadedData = Response.Headers["Range"];
EndIf;
If Not ValueIsFilled(UploadedData) Then
OPI_Tools.ProcessResponse(Response);
Return Response;
EndIf;
UploadedData = StrReplace(UploadedData, "bytes=", "");
UploadedData = StrReplace(UploadedData, "bytes =", "");
ArrayOfInformation = StrSplit(UploadedData, "-", False);
PartsRequired = 2;
PartsRequired = 2;
If Not ArrayOfInformation.Count() = PartsRequired Then
OPI_Tools.ProcessResponse(Response);
Return Response;
EndIf;
CurrentPosition = Number(ArrayOfInformation[1]) + 1;
Return "";
EndFunction
#EndRegion

264
src/en/OInt/core/Modules/OPI_GoogleSheets.os
View File

@ -43,90 +43,90 @@
// Create spreadsheet
// Creates a new spreadsheet
//
//
// Parameters:
// Token - String - Token - token
// Name - String - Name - title
// ArrayOfSheetNames - Array of String - Array of names to add new sheets to the spreadsheet - sheets
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CreateSpreadsheet(Val Token, Val Name, Val ArrayOfSheetNames) Export
OPI_TypeConversion.GetLine(Name);
OPI_TypeConversion.GetCollection(ArrayOfSheetNames);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets";
URL = "https://sheets.googleapis.com/v4/spreadsheets";
Properties = New Structure("title" , Name);
Sheets = New Array;
Sheets = New Array;
FillSheetArray(ArrayOfSheetNames, Sheets);
Parameters = New Structure;
OPI_Tools.AddField("properties", Properties, "Collection", Parameters);
OPI_Tools.AddField("sheets" , Sheets , "Collection", Parameters);
OPI_Tools.AddField("sheets" , Sheets , "Collection", Parameters);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Get spreadsheet
// Gets information about the spreadsheet by ID
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Spreadsheet identifier - spreadsheet
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetSpreadsheet(Val Token, Val Identifier) Export
OPI_TypeConversion.GetLine(Identifier);
OPI_TypeConversion.GetLine(Identifier);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Identifier;
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Identifier;
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Change spreadsheet name
// Changes the name of the existing spreadsheet
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - SpreadsheetID - spreadsheet
// Name - String - New name - title
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function EditSpreadsheetTitle(Val Token, Val Spreadsheet, Val Name) Export
OPI_TypeConversion.GetLine(Spreadsheet);
OPI_TypeConversion.GetLine(Name);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
Change = New Structure("title", Name);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
Change = New Structure("title", Name);
ChangeRequest = New Structure("properties,fields", Change, "title");
Request = New Structure("updateSpreadsheetProperties", ChangeRequest);
Request = New Structure("updateSpreadsheetProperties", ChangeRequest);
ArrayOfRequests = New Array;
ArrayOfRequests.Add(Request);
Parameters = New Structure("requests", ArrayOfRequests);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
#EndRegion
@ -135,95 +135,95 @@ EndFunction
// Add sheet
// Adds a new sheet to the spreadsheet
//
//
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - Spreadsheet identifier - spreadsheet
// Name - String - NewSheetName - title
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function AddSheet(Val Token, Val Spreadsheet, Val Name) Export
OPI_TypeConversion.GetLine(Spreadsheet);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
Sheet = CreateSheet(Name);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
Sheet = CreateSheet(Name);
Requests = New Array;
Change = New Structure("addSheet", Sheet);
Change = New Structure("addSheet", Sheet);
Requests.Add(Change);
Parameters = New Structure("requests", Requests);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Delete sheet
// Deletes a sheet from the spreadsheet
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - Spreadsheet identifier - spreadsheet
// Sheet - String - IdentifierOfSheetToDelete - sheet
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteSheet(Val Token, Val Spreadsheet, Val Sheet) Export
OPI_TypeConversion.GetLine(Spreadsheet);
OPI_TypeConversion.GetLine(Sheet);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
Requests = New Array;
Sheet = New Structure("sheetId" , Sheet);
Change = New Structure("deleteSheet", Sheet);
Sheet = New Structure("sheetId" , Sheet);
Change = New Structure("deleteSheet", Sheet);
Requests.Add(Change);
Parameters = New Structure("requests", Requests);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Copy sheet
// Copies a sheet from one spreadsheet to another
//
//
// Parameters:
// Token - String - Token - token
// From - String - Source spreadsheet ID - from
// Target - String - Destination spreadsheet ID - to
// Sheet - String - CopiedSheetID - sheet
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CopySheet(Val Token, Val From, Val Target, Val Sheet) Export
OPI_TypeConversion.GetLine(From);
OPI_TypeConversion.GetLine(Target);
OPI_TypeConversion.GetLine(Sheet);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/"
URL = "https://sheets.googleapis.com/v4/spreadsheets/"
+ From
+ "/sheets/"
+ Sheet
+ ":copyTo";
Parameters = New Structure("destinationSpreadsheetId", Target);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Parameters = New Structure("destinationSpreadsheetId", Target);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
#EndRegion
@ -232,14 +232,14 @@ EndFunction
// Set cell values
// Sets sheet cell values
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - SpreadsheetID - spreadsheet
// Spreadsheet - String - SpreadsheetID - spreadsheet
// ValueMapping - Map Of KeyAndValue - Fill data where the key is the cell name like A1 - data
// Sheet - String - Sheet name (first sheet by default) - sheetname
// MajorDimension - String - Main dimension when filling the array range - dim
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function SetCellValues(Val Token
@ -247,90 +247,90 @@ Function SetCellValues(Val Token
, Val ValueMapping
, Val Sheet = ""
, Val MajorDimension = "COLUMNS") Export
OPI_TypeConversion.GetLine(Spreadsheet);
OPI_TypeConversion.GetCollection(ValueMapping);
If Not TypeOf(ValueMapping) = Type("Structure")
If Not TypeOf(ValueMapping) = Type("Structure")
And Not TypeOf(ValueMapping) = Type("Map") Then
Return "Failed to convert the structure of values to a collection";
EndIf;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchUpdate";
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchUpdate";
DataArray = FormCellDataArray(ValueMapping, MajorDimension, Sheet);
Parameters = New Structure("data,valueInputOption", DataArray, "USER_ENTERED");
Response = OPI_Tools.Post(URL, Parameters, Headers);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Clear cells
// Clears the value in cells
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - SpreadsheetID - spreadsheet
// CellsArray - Array of String - Array of cells like A1 to be cleared - cells
// Sheet - String - Sheet name (first sheet by default) - sheetname
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function ClearCells(Val Token, Val Spreadsheet, Val CellsArray, Val Sheet = "") Export
OPI_TypeConversion.GetLine(Spreadsheet);
OPI_TypeConversion.GetCollection(CellsArray);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchClear";
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchClear";
FormCellNameArray(CellsArray, Sheet);
Parameters = New Structure("ranges", CellsArray);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Get cell values
// Gets cell values of the table
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - SpreadsheetID - spreadsheet
// CellsArray - Array of String - Array of A1 type cells to get (whole sheet if not filled) - cells
// Sheet - String - Sheet name (first sheet by default) - sheetname
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetCellValues(Val Token, Val Spreadsheet, Val CellsArray = "", Val Sheet = "") Export
OPI_TypeConversion.GetLine(Spreadsheet);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchGet";
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchGet";
If ValueIsFilled(CellsArray) Then
OPI_TypeConversion.GetCollection(CellsArray);
OPI_TypeConversion.GetCollection(CellsArray);
FormCellNameArray(CellsArray, Sheet);
First = True;
First = True;
For Each Cell In CellsArray Do
Delimiter = ?(First, "?", "&");
URL = URL + Delimiter + "ranges=" + Cell;
First = False;
URL = URL + Delimiter + "ranges =" + Cell;
First = False;
EndDo;
Else
URL = URL + "?ranges='" + Sheet + "'";
URL = URL + "?ranges ='" + Sheet + "'";
EndIf;
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
#EndRegion
@ -340,75 +340,75 @@ EndFunction
#Region Private
Procedure FillSheetArray(Val ArrayOfNames, SheetArray)
For Each SheetName In ArrayOfNames Do
Sheet = CreateSheet(SheetName);
SheetArray.Add(Sheet);
EndDo;
EndProcedure
Procedure AddSheetName(Cell, Val Sheet)
If ValueIsFilled(Sheet) Then
Cell = "'" + Sheet + "'!" + Cell;
EndIf;
EndProcedure
Function CreateSheet(Val Name)
OPI_TypeConversion.GetLine(Name);
SheetProperties = New Structure("title" , Name);
Sheet = New Structure("properties", SheetProperties);
Sheet = New Structure("properties", SheetProperties);
Return Sheet;
EndFunction
Function FormCellDataArray(Val ValueStructure, Val MajorDimension, Val Sheet)
OPI_TypeConversion.GetLine(Sheet);
DataArray = New Array;
For Each CellData In ValueStructure Do
CurrentValue = CellData.Value;
CurrentKey = CellData.Key;
CurrentKey = CellData.Key;
AddSheetName(CurrentKey, Sheet);
OPI_TypeConversion.GetArray(CurrentValue);
CurrentData = New Map;
CurrentData = New Map;
CurrentArray = New Array;
CurrentArray.Add(CurrentValue);
OPI_Tools.AddField("range" , CurrentKey , "String", CurrentData);
OPI_Tools.AddField("values" , CurrentArray , "Array", CurrentData);
OPI_Tools.AddField("range" , CurrentKey , "String", CurrentData);
OPI_Tools.AddField("values" , CurrentArray , "Array" , CurrentData);
OPI_Tools.AddField("majorDimension", MajorDimension, "String", CurrentData);
DataArray.Add(CurrentData);
EndDo;
Return DataArray;
EndFunction
Procedure FormCellNameArray(Val ArrayOfNames, Val Sheet)
OPI_TypeConversion.GetLine(Sheet);
For N = 0 To ArrayOfNames.UBound() Do
OPI_TypeConversion.GetLine(Sheet);
For N = 0 To ArrayOfNames.UBound() Do
AddSheetName(ArrayOfNames[N], Sheet);
EndDo;
EndProcedure
#EndRegion

84
src/en/OInt/core/Modules/OPI_GoogleWorkspace.os
View File

@ -41,97 +41,97 @@
// Generate code retrieval link
// Returns URL for browser authorization
//
//
// Parameters:
// ClientID - String - Client ID - id
// Calendar - Boolean - Calendar methods permission - calendar
// Drive - Boolean - Drive methods permission - drive
// Sheets - Boolean - Sheets methods permission - sheets
//
//
// Returns:
// String - Code retrieval link
Function FormCodeRetrievalLink(Val ClientID
, Val Calendar = True
, Val Drive = True
, Val Sheets = True) Export
OPI_TypeConversion.GetLine(ClientID);
OPI_TypeConversion.GetBoolean(Calendar);
OPI_TypeConversion.GetBoolean(Sheets);
OPI_TypeConversion.GetBoolean(Drive);
URL = "https://accounts.google.com/o/oauth2/auth";
URLParameters = New Structure;
URLParameters.Insert("response_type", "code");
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("redirect_uri" , "http://localhost");
URLParameters.Insert("access_type" , "offline");
URLParameters.Insert("scope" , GetPermissionsList(Calendar, Drive, Sheets));
URLParameters.Insert("access_type" , "offline");
URLParameters.Insert("scope" , GetPermissionsList(Calendar, Drive, Sheets));
URL = URL + OPI_Tools.RequestParametersToString(URLParameters);
Return URL;
EndFunction
// Get token by code
// Gets token by code from browser authorization
//
//
// Parameters:
// ClientID - String - Client ID - id
// ClientSecret - String - Client secret - secret
// Code - String - Code from browser - code
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetTokenByCode(Val ClientID, Val ClientSecret, Val Code) Export
OPI_TypeConversion.GetLine(ClientID);
OPI_TypeConversion.GetLine(ClientSecret);
OPI_TypeConversion.GetLine(Code);
URL = "https://accounts.google.com/o/oauth2/token";
URLParameters = New Structure;
URLParameters.Insert("grant_type" , "authorization_code");
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("grant_type" , "authorization_code");
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("client_secret", ClientSecret);
URLParameters.Insert("redirect_uri" , "http://localhost");
URLParameters.Insert("code" , Code);
URLParameters.Insert("redirect_uri" , "http://localhost");
URLParameters.Insert("code" , Code);
Response = OPI_Tools.Post(URL, URLParameters, , False);
Return Response;
EndFunction
// Refresh token
// Updates token by Refresh token
//
//
// Parameters:
// ClientID - String - Client ID - id
// ClientSecret - String - Client secret - secret
// RefreshToken - String - Refresh token - refresh
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function RefreshToken(Val ClientID, Val ClientSecret, Val RefreshToken) Export
OPI_TypeConversion.GetLine(ClientID);
OPI_TypeConversion.GetLine(ClientSecret);
OPI_TypeConversion.GetLine(RefreshToken);
URL = "https://accounts.google.com/o/oauth2/token";
URLParameters = New Structure;
URLParameters.Insert("grant_type" , "refresh_token");
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("client_secret", ClientSecret);
URLParameters.Insert("grant_type" , "refresh_token");
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("client_secret", ClientSecret);
URLParameters.Insert("refresh_token", RefreshToken);
Response = OPI_Tools.Post(URL, URLParameters, , False);
Return Response;
EndFunction
@ -141,14 +141,14 @@ EndFunction
#Region Internal
Function GetAuthorizationHeader(Val Token) Export
OPI_TypeConversion.GetLine(Token);
Headers = New Map;
Headers.Insert("Authorization", "Bearer " + Token);
Return Headers;
EndFunction
#EndRegion
@ -156,23 +156,23 @@ EndFunction
#Region ServiceProceduresAndFunctions
Function GetPermissionsList(Calendar, Drive, Sheets)
PermissionsArray = New Array;
If Calendar Then
PermissionsArray.Add("https://www.googleapis.com/auth/calendar");
EndIf;
If Drive Then
PermissionsArray.Add("https://www.googleapis.com/auth/drive");
EndIf;
If Sheets Then
PermissionsArray.Add("https://www.googleapis.com/auth/spreadsheets");
EndIf;
Return StrConcat(PermissionsArray, " ");
EndFunction
#EndRegion

554
src/en/OInt/core/Modules/OPI_Notion.os
View File

File diff suppressed because it is too large Load Diff

652
src/en/OInt/core/Modules/OPI_Slack.os
View File

File diff suppressed because it is too large Load Diff

640
src/en/OInt/core/Modules/OPI_Telegram.os
View File

File diff suppressed because it is too large Load Diff

538
src/en/OInt/core/Modules/OPI_Twitter.os
View File

@ -48,83 +48,83 @@
// Get authorization link
// Forms a link for authorization via the browser
//
//
// Parameters:
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// String - URL for browser transition
Function GetAuthorizationLink(Parameters = "") Export
Parameters_ = GetStandardParameters(Parameters);
URLParameters = New Structure;
URLParameters.Insert("response_type" , "code");
URLParameters.Insert("client_id" , Parameters_["client_id"]);
URLParameters.Insert("redirect_uri" , Parameters_["redirect_uri"]);
URLParameters.Insert("scope" , Parameters_["scope"]);
URLParameters.Insert("state" , "state");
URLParameters.Insert("code_challenge" , "challenge");
URLParameters.Insert("response_type" , "code");
URLParameters.Insert("client_id" , Parameters_["client_id"]);
URLParameters.Insert("redirect_uri" , Parameters_["redirect_uri"]);
URLParameters.Insert("scope" , Parameters_["scope"]);
URLParameters.Insert("state" , "state");
URLParameters.Insert("code_challenge" , "challenge");
URLParameters.Insert("code_challenge_method", "plain");
URLParameters = OPI_Tools.RequestParametersToString(URLParameters);
Link = "https://twitter.com/i/oauth2/authorize" + URLParameters;
Link = "https://twitter.com/i/oauth2/authorize" + URLParameters;
Return Link;
EndFunction
// Get token
// Gets the token by the code received when authorizing using the link from GetAuthorizationLink
//
//
// Parameters:
// Code - String - Code obtained from authorization See GetAuthorizationLink - code
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function GetToken(Val Code, Val Parameters = "") Export
OPI_TypeConversion.GetLine(Code);
Parameters_ = GetStandardParameters(Parameters);
RequestParameters = New Structure;
RequestParameters.Insert("code" , Code);
RequestParameters.Insert("grant_type" , "authorization_code");
RequestParameters.Insert("client_id" , Parameters_["client_id"]);
RequestParameters.Insert("code" , Code);
RequestParameters.Insert("grant_type" , "authorization_code");
RequestParameters.Insert("client_id" , Parameters_["client_id"]);
RequestParameters.Insert("redirect_uri" , Parameters_["redirect_uri"]);
RequestParameters.Insert("code_verifier", "challenge");
Response = OPI_Tools.Post("https://api.twitter.com/2/oauth2/token"
, RequestParameters, , False);
Return Response;
EndFunction
// Refresh token
// Refresh token
// Updates the v2 token using the refresh_token
//
//
// Parameters:
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function RefreshToken(Val Parameters = "") Export
Parameters_ = GetStandardParameters(Parameters);
Refresh = "refresh_token";
Refresh = "refresh_token";
RequestParameters = New Structure;
RequestParameters.Insert(Refresh , Parameters_[Refresh]);
RequestParameters.Insert(Refresh , Parameters_[Refresh]);
RequestParameters.Insert("grant_type" , Refresh);
RequestParameters.Insert("client_id" , Parameters_["client_id"]);
RequestParameters.Insert("client_id" , Parameters_["client_id"]);
Response = OPI_Tools.Post("https://api.twitter.com/2/oauth2/token"
, RequestParameters, , False);
Return Response;
EndFunction
@ -133,23 +133,23 @@ EndFunction
// Method for insertion into an http service, the address of which is specified in redirect_uri
// Calls the token acquisition method, as for obtaining a token from the code received
// on redirect_uri after authorization via the browser is only 30 seconds
//
//
// Parameters:
// Request - HTTPServiceRequest - Request coming to the http service
//
//
// Returns:
// HTTPResponse, Arbitrary, BinaryData - Result of reading the JSON response from the server
Function HandleIncomingRequestAfterAuthorization(Request) Export
Code = Request.RequestParameters["code"];
Code = Request.RequestParameters["code"];
TokenResponse = GetToken(Code);
// BSLLS:CommentedCode-off
// Preferred token storage
// Constants.TwitterRefresh.Set(ResponseToken["refresh_token"]);
// Constants.TwitterToken.Set(ResponseToken["access_token"]);
// BSLLS:CommentedCode-on
Return TokenResponse;
EndFunction
@ -160,189 +160,189 @@ EndFunction
// !NOCLI
// Create custom tweet
//
//
// Parameters:
// Text - String - Tweet text
// MediaArray - Array of String, BinaryData - Array of binary data or file paths
// PollOptionsArray - Array of String - Array of poll options, if necessary
// PollDuration - String, Number - Poll duration if necessary (poll without duration is not created)
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreateCustomTweet(Val Text = ""
, Val MediaArray = ""
, Val PollOptionsArray = ""
, Val PollDuration = ""
, Val Parameters = "") Export
, Val Parameters = "") Export
OPI_TypeConversion.GetLine(Text);
OPI_TypeConversion.GetLine(PollDuration);
If ValueIsFilled(MediaArray) Then
OPI_TypeConversion.GetCollection(MediaArray);
EndIf;
If ValueIsFilled(PollOptionsArray) Then
OPI_TypeConversion.GetCollection(PollOptionsArray);
EndIf;
Parameters_ = GetStandardParameters(Parameters);
URL = "https://api.twitter.com/2/tweets";
Array = "Array";
Fields = New Map;
URL = "https://api.twitter.com/2/tweets";
Array = "Array";
Fields = New Map;
If ValueIsFilled(Text) Then
Fields.Insert("text", Text);
EndIf;
If TypeOf(PollOptionsArray) = Type(Array) And ValueIsFilled(PollDuration) Then
PollDuration = Number(PollDuration);
If PollOptionsArray.Count() > 0 Then
OptionStructure = New Structure("options,duration_minutes", PollOptionsArray, PollDuration);
Fields.Insert("poll", OptionStructure);
EndIf;
EndIf;
If TypeOf(MediaArray) = Type(Array) Then
If MediaArray.Count() > 0 Then
Fields.Insert("media", New Structure("media_ids", MediaArray));
EndIf;
EndIf;
Authorization = CreateAuthorizationHeaderV2(Parameters_);
Response = OPI_Tools.Post(URL, Fields, Authorization);
Response = OPI_Tools.Post(URL, Fields, Authorization);
Return Response;
EndFunction
// Create text tweet
// Creates a tweet without attachments
//
//
// Parameters:
// Text - String - Tweet text - text
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreateTextTweet(Val Text, Val Parameters = "") Export
Return CreateCustomTweet(Text, , , , Parameters);
Return CreateCustomTweet(Text, , , , Parameters);
EndFunction
// Create image tweet
// Creates a tweet with an image attachment
//
//
// Parameters:
// Text - String - Tweet text - text
// ImageArray - Array of String, BinaryData - Image files array - pictures
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreateImageTweet(Val Text, Val ImageArray, Val Parameters = "") Export
MediaArray = UploadAttachmentsArray(ImageArray, "photo", Parameters);
Return CreateCustomTweet(Text, MediaArray, , , Parameters);
Return CreateCustomTweet(Text, MediaArray, , , Parameters);
EndFunction
// Create gif tweet
// Creates a tweet with a gif attachment
//
//
// Parameters:
// Text - String - Tweet text - text
// GifsArray - Array of String, BinaryData - Gif files array - gifs
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreateGifTweet(Val Text, Val GifsArray, Val Parameters = "") Export
MediaArray = UploadAttachmentsArray(GifsArray, "animated_gif", Parameters);
Return CreateCustomTweet(Text, MediaArray, , , Parameters);
Return CreateCustomTweet(Text, MediaArray, , , Parameters);
EndFunction
// Create video tweet
// Creates a tweet with a video attachment
//
//
// Parameters:
// Text - String - Tweet text - text
// VideosArray - Array of String, BinaryData - Video files array - videos
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreateVideoTweet(Val Text, Val VideosArray, Val Parameters = "") Export
MediaArray = UploadAttachmentsArray(VideosArray, "video", Parameters);
Return CreateCustomTweet(Text, MediaArray, , , Parameters);
EndFunction
// Create poll tweet
// Creates a tweet with a poll
//
//
// Parameters:
// Text - String - Tweet text - text
// OptionArray - Array of String - Poll options array - options
// Duration - String, Number - Poll duration - duration
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreatePollTweet(Val Text, Val OptionArray, Val Duration, Val Parameters = "") Export
Return CreateCustomTweet(Text, , OptionArray, Duration, Parameters);
Return CreateCustomTweet(Text, , OptionArray, Duration, Parameters);
EndFunction
// Upload attachments array !NOCLI
// Uploads files to the server and returns their IDs
//
//
// Parameters:
// ArrayOfFiles - Array of String, BinaryData - Files array
// AttachmentsType - String - Attachments type
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Array Of String - Media ID array
Function UploadAttachmentsArray(Val ArrayOfFiles, Val AttachmentsType, Val Parameters = "") Export
OPI_TypeConversion.GetLine(AttachmentsType);
OPI_TypeConversion.GetCollection(ArrayOfFiles);
MediaArray = New Array;
MediaArray = New Array;
Parameters_ = GetStandardParameters(Parameters);
MIS = "media_id_string";
MIS = "media_id_string";
If ValueIsFilled(ArrayOfFiles) Then
For Each SendingFile In ArrayOfFiles Do
OPI_TypeConversion.GetBinaryData(SendingFile);
Response = UploadMediaFile(SendingFile, AttachmentsType, Parameters_);
MediaID = Response[MIS];
MediaID = Response[MIS];
If Not ValueIsFilled(MediaID) Then
Return Response;
EndIf;
MediaArray.Add(MediaID);
EndDo;
EndIf;
Return MediaArray;
EndFunction
#EndRegion
@ -351,195 +351,195 @@ EndFunction
#Region Private
Function UploadMediaFile(Val File, Val Type, Val Parameters)
Function UploadMediaFile(Val File, Val Type, Val Parameters)
OPI_TypeConversion.GetBinaryData(File);
RequestType = "POST";
RequestType = "POST";
Parameters_ = GetStandardParameters(Parameters);
URL = "https://upload.twitter.com/1.1/media/upload.json";
If Type = "photo" Then
URL = "https://upload.twitter.com/1.1/media/upload.json";
If Type = "photo" Then
Fields = New Structure;
Fields.Insert("media_data" , Base64String(File));
Fields.Insert("media_data" , Base64String(File));
Fields.Insert("media_category", Type);
Authorization = CreateAuthorizationHeaderV1(Parameters_, Fields, RequestType, URL);
Response = OPI_Tools.Post(URL, Fields, Authorization, False);
Authorization = CreateAuthorizationHeaderV1(Parameters_, Fields, RequestType, URL);
Response = OPI_Tools.Post(URL, Fields, Authorization, False);
Else
Response = UploadMediaInParts(File, Type, RequestType, URL, Parameters_);
EndIf;
Return Response;
EndFunction
Function UploadMediaInParts(Val File, Val Type, Val RequestType, Val URL, Parameters)
Unit = 1024;
Count = 4;
Unit = 1024;
Count = 4;
MediaKey = "media_key";
MIS = "media_id_string";
Command = "command";
Size = File.Size();
MIS = "media_id_string";
Command = "command";
Size = File.Size();
MIMETypeMapping = New Map;
MIMETypeMapping.Insert("photo" , "image/jpeg");
MIMETypeMapping.Insert("video" , "video/mp4");
MIMETypeMapping.Insert("photo" , "image/jpeg");
MIMETypeMapping.Insert("video" , "video/mp4");
MIMETypeMapping.Insert("animated_gif", "image/gif");
ChunkSize = Count * Unit * Unit;
ChunkSize = Count * Unit * Unit;
ArrayReading = SplitBinaryData(File, ChunkSize);
Fields = New Structure;
Fields.Insert(Command , "INIT");
Fields.Insert("total_bytes" , OPI_Tools.NumberToString(Size));
Fields.Insert("media_type" , MIMETypeMapping.Get(Type));
Fields.Insert(Command , "INIT");
Fields.Insert("total_bytes" , OPI_Tools.NumberToString(Size));
Fields.Insert("media_type" , MIMETypeMapping.Get(Type));
Fields.Insert("media_category" , Type);
Authorization = CreateAuthorizationHeaderV1(Parameters, Fields, RequestType, URL);
InitializationResponse = OPI_Tools.Post(URL, Fields, Authorization, False);
InitializationKey = InitializationResponse[MediaKey];
InitializationID = InitializationResponse[MIS];
InitializationKey = InitializationResponse[MediaKey];
InitializationID = InitializationResponse[MIS];
If Not ValueIsFilled(InitializationKey) Or Not ValueIsFilled(InitializationID) Then
Return InitializationResponse;
Return InitializationResponse;
EndIf;
Counter = 0;
For Each Part In ArrayReading Do
Fields = New Structure;
Fields.Insert(Command , "APPEND");
Fields.Insert("media_key" , InitializationKey);
Fields.Insert(Command , "APPEND");
Fields.Insert("media_key" , InitializationKey);
Fields.Insert("segment_index" , OPI_Tools.NumberToString(Counter));
Fields.Insert("media" , Part);
Fields.Insert("media" , Part);
Authorization = CreateAuthorizationHeaderV1(Parameters, New Structure, RequestType, URL);
OPI_Tools.PostMultipart(URL, Fields, , , Authorization);
Counter = Counter + 1;
EndDo;
Fields = New Structure;
Fields.Insert(Command , "FINALIZE");
Fields.Insert(Command , "FINALIZE");
Fields.Insert("media_id", InitializationID);
ProcessingStatus = GetProcessingStatus(Parameters, Fields, URL);
If Not TypeOf(ProcessingStatus) = Type("String") Then
Return ProcessingStatus;
EndIf;
Response = WaitForProcessingCompletion(ProcessingStatus, InitializationID, URL, Parameters);
Return Response;
EndFunction
Function WaitForProcessingCompletion(Val ProcessingStatus, Val InitializationID, Val URL, Val Parameters)
ProcessingInfo = "processing_info";
Command = "command";
Fields = New Structure;
Fields.Insert(Command , "STATUS");
Command = "command";
Fields = New Structure;
Fields.Insert(Command , "STATUS");
Fields.Insert("media_id", InitializationID);
WHile String(ProcessingStatus) = "pending" Or String(ProcessingStatus) = "in_progress" Do
Authorization = CreateAuthorizationHeaderV1(Parameters, Fields, "GET", URL);
Response = OPI_Tools.Get(URL, Fields, Authorization);
Information = Response[ProcessingInfo];
Authorization = CreateAuthorizationHeaderV1(Parameters, Fields, "GET", URL);
Response = OPI_Tools.Get(URL, Fields, Authorization);
Information = Response[ProcessingInfo];
If Not ValueIsFilled(Information) Then
Return Response;
EndIf;
ProcessingStatus = Information["state"];
If Not ValueIsFilled(ProcessingStatus) Then
Return Response;
EndIf;
EndDo;
If ProcessingStatus = "failed" Then
Raise "Twitter could not process the video you uploaded";
EndIf;
Return Response;
EndFunction
Function GetStandardParameters(Val Parameters = "")
// The definition of the data required for the work is collected here.
// For Twitter, this is quite a significant set, which is due to the presence of 2 APIs at once,
// which, at the same time, are not created for different tasks, but are simply versions of each other.
// The current version of the API is v2 and it requires obtaining temporary tokens. Despite the fact,
// that Twitter insists on using this latest version, they somehow managed not to transfer
// file upload mechanism and some others from the old version - v1.1. Therefore, something needs to be done
// file upload mechanism and some others from the old version - v1.1. Therefore, something needs to be done
// on version 1.1, and something on 2: up to the point that they removed the ability to post tweets from v1.1,
// but only through it you can add a picture to the tweet. At the same time, their authentication methods and tokens are different
// The world gigacorporation of Elon Musk, by the way, a reminder ;)
// P.S The following is often referred to as the "Twitter Developer settings page" - this
// P.S The following is often referred to as the "Twitter Developer settings page" - this
// https://developer.twitter.com/en/portal/dashboard and chosing of project from list (key icon)
Parameters_ = New Map;
Parameters_ = New Map;
Permissions = "tweet.read tweet.write tweet.moderate.write users.read "
+ "follows.read follows.write offline.access space.read mute.read "
+ "mute.write like.read like.write list.read list.write block.read "
+ "block.write bookmark.read bookmark.write";
+ "block.write bookmark.read bookmark.write";
// Data for API v2
// redirect_uri - URL of your http service (or other request handler) for authorization
// scope - a set of permissions for the received key. Can be any, but offline.access is mandatory
// client_id - From OAuth 2.0 Client ID and Client Secret settings page of Twitter Developer
// client_secret - From OAuth 2.0 Client ID and Client Secret settings page of Twitter Developer
// access_token - GetAuthorizationLink() -> Browser -> code will come to redirect_uri -> GetToken(code)
// refresh_token - Comes together with access_token and is used to refresh it (access_token lifetime - 2 hr)
// The update is done using the UpdateToken method with new access_token and refresh_token.
// For the next update, you need to use a new refresh_token, so hardcode
// won't work (access_token won't work either)
// The update is done using the UpdateToken method with new access_token and refresh_token.
// For the next update, you need to use a new refresh_token, so hardcode
// won't work (access_token won't work either)
// |--> RefreshToken() ->|access_token --> 2 hrs. lifetime
// | |refresh_token --|
// |--------[after 2 hrs.]-------------------|
// Data for API v1.1
// oauth_token - From Authentication Tokens -> Access Token and Secret settings page of Twitter Developer
// oauth_token - From Authentication Tokens -> Access Token and Secret settings page of Twitter Developer
// oauth_token_secret - From Authentication Tokens -> Access Token and Secret settings page of Twitter Developer
// oauth_consumer_key - From Consumer Keys -> Access Token and Secret settings page of Twitter Developer
// oauth_consumer_secret - From Consumer Keys -> Access Token and Secret settings page of Twitter Developer
// These tokens do not need to be updated
Parameters_.Insert("redirect_uri" , "");
Parameters_.Insert("scope" , Permissions);
Parameters_.Insert("client_id" , "");
Parameters_.Insert("client_secret" , "");
Parameters_.Insert("access_token" , ""); // Should be something like Constants.TwitterToken.Get()
Parameters_.Insert("refresh_token" , ""); // Should be something like Constants.TwitterRefresh.Get()
Parameters_.Insert("oauth_token" , "");
Parameters_.Insert("oauth_token_secret" , "");
Parameters_.Insert("oauth_consumer_key" , "");
Parameters_.Insert("redirect_uri" , "");
Parameters_.Insert("scope" , Permissions);
Parameters_.Insert("client_id" , "");
Parameters_.Insert("client_secret" , "");
Parameters_.Insert("access_token" , ""); // Should be something like Constants.TwitterToken.Get()
Parameters_.Insert("refresh_token" , ""); // Should be something like Constants.TwitterRefresh.Get()
Parameters_.Insert("oauth_token" , "");
Parameters_.Insert("oauth_token_secret" , "");
Parameters_.Insert("oauth_consumer_key" , "");
Parameters_.Insert("oauth_consumer_secret", "");
OPI_TypeConversion.GetCollection(Parameters);
If TypeOf(Parameters) = Type("Structure") Or TypeOf(Parameters) = Type("Map") Then
For Each PassedParameter In Parameters Do
Parameters_.Insert(PassedParameter.Key, OPI_Tools.NumberToString(PassedParameter.Value));
@ -551,137 +551,137 @@ Function GetStandardParameters(Val Parameters = "")
EndFunction
Function CreateAuthorizationHeaderV1(Val Parameters, Val Fields, Val RequestType, Val URL)
CurrentDate = OPI_Tools.GetCurrentDate();
CurrentDate = OPI_Tools.GetCurrentDate();
AuthorizationHeader = "";
HashingMethod = "HMAC-SHA1";
APIVersion = "1.0";
SignatureString = "";
Signature = "";
HashingMethod = "HMAC-SHA1";
APIVersion = "1.0";
SignatureString = "";
Signature = "";
OCK = "oauth_consumer_key";
OTK = "oauth_token";
CurrentUNIXDate = OPI_Tools.UNIXTime(CurrentDate);
CurrentUNIXDate = OPI_Tools.NumberToString(CurrentUNIXDate);
ParametersTable = New ValueTable;
CurrentUNIXDate = OPI_Tools.UNIXTime(CurrentDate);
CurrentUNIXDate = OPI_Tools.NumberToString(CurrentUNIXDate);
ParametersTable = New ValueTable;
ParametersTable.Columns.Add("Key");
ParametersTable.Columns.Add("Value");
For Each Field In Fields Do
NewLine = ParametersTable.Add();
NewLine.Key = Field.Key;
For Each Field In Fields Do
NewLine = ParametersTable.Add();
NewLine.Key = Field.Key;
NewLine.Value = Field.Value;
EndDo;
NewLine = ParametersTable.Add();
NewLine.Key = OCK;
NewLine = ParametersTable.Add();
NewLine.Key = OCK;
NewLine.Value = Parameters[OCK];
NewLine = ParametersTable.Add();
NewLine.Key = OTK;
NewLine = ParametersTable.Add();
NewLine.Key = OTK;
NewLine.Value = Parameters[OTK];
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_version";
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_version";
NewLine.Value = APIVersion;
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_signature_method";
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_signature_method";
NewLine.Value = HashingMethod;
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_timestamp";
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_timestamp";
NewLine.Value = CurrentUNIXDate;
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_nonce";
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_nonce";
NewLine.Value = CurrentUNIXDate;
For Each TableRow In ParametersTable Do
TableRow.Key = EncodeString(TableRow.Key, StringEncodingMethod.URLencoding);
TableRow.Key = EncodeString(TableRow.Key, StringEncodingMethod.URLencoding);
TableRow.Value = EncodeString(TableRow.Value, StringEncodingMethod.URLencoding);
EndDo;
ParametersTable.Sort("Key");
For Each TableRow In ParametersTable Do
SignatureString = SignatureString
+ TableRow.Key
+ "="
SignatureString = SignatureString
+ TableRow.Key
+ " ="
+ TableRow.Value
+ "&";
EndDo;
SignatureString = Left(SignatureString, StrLen(SignatureString) - 1);
SignatureString = Upper(RequestType)
+ "&"
+ EncodeString(URL, StringEncodingMethod.URLencoding)
SignatureString = Upper(RequestType)
+ "&"
+ EncodeString(URL , StringEncodingMethod.URLencoding)
+ "&"
+ EncodeString(SignatureString, StringEncodingMethod.URLencoding);
Signature = EncodeString(Parameters["oauth_consumer_secret"], StringEncodingMethod.URLencoding)
+ "&"
+ "&"
+ EncodeString(Parameters["oauth_token_secret"], StringEncodingMethod.URLencoding);
Signature = OPI_Cryptography.HMAC(GetBinaryDataFromString(Signature)
, GetBinaryDataFromString(SignatureString)
, HashFunction.SHA1
, 64);
Signature = EncodeString(Base64String(Signature), StringEncodingMethod.URLencoding);
Delimiter = """,";
AuthorizationHeader = AuthorizationHeader
AuthorizationHeader = AuthorizationHeader
+ "OAuth "
+ "oauth_consumer_key=""" + Parameters[OCK] + Delimiter
+ "oauth_token=""" + Parameters[OTK] + Delimiter
+ "oauth_consumer_key =""" + Parameters[OCK] + Delimiter
+ "oauth_token =""" + Parameters[OTK] + Delimiter
+ "oauth_signature_method=""" + HashingMethod + Delimiter
+ "oauth_timestamp=""" + CurrentUNIXDate + Delimiter
+ "oauth_nonce=""" + CurrentUNIXDate + Delimiter
+ "oauth_version=""" + APIVersion + Delimiter
+ "oauth_signature=""" + Signature;
+ "oauth_timestamp =""" + CurrentUNIXDate + Delimiter
+ "oauth_nonce =""" + CurrentUNIXDate + Delimiter
+ "oauth_version =""" + APIVersion + Delimiter
+ "oauth_signature =""" + Signature;
HeaderMapping = New Map;
HeaderMapping.Insert("authorization", AuthorizationHeader);
Return HeaderMapping;
EndFunction
Function CreateAuthorizationHeaderV2(Val Parameters)
ReturnMapping = New Map;
ReturnMapping.Insert("Authorization", "Bearer " + Parameters["access_token"]);
Return ReturnMapping;
EndFunction
Function GetProcessingStatus(Val Parameters, Val Fields, Val URL)
ProcessingInfo = "processing_info";
ProcessingInfo = "processing_info";
Authorization = CreateAuthorizationHeaderV1(Parameters, Fields, "POST", URL);
Response = OPI_Tools.Post(URL, Fields, Authorization, False);
Response = OPI_Tools.Post(URL, Fields, Authorization, False);
Information = Response[ProcessingInfo];
If Not ValueIsFilled(Information) Then
Return Response;
EndIf;
ProcessingStatus = Information["state"];
If Not ValueIsFilled(ProcessingStatus) Then
Return Response;
Else
Return ProcessingStatus;
EndIf;
EndIf;
EndFunction
#EndRegion

1578
src/en/OInt/core/Modules/OPI_VK.os
View File

File diff suppressed because it is too large Load Diff

234
src/en/OInt/core/Modules/OPI_Viber.os
View File

@ -23,7 +23,7 @@
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
// https://github.com/Bayselonarrend/OpenIntegrations
// BSLLS:LatinAndCyrillicSymbolInWord-off
@ -46,55 +46,55 @@
// which will return 200 and a genuine SSL certificate. If there is a certificate and the database is published
// on the server - you can use an HTTP service. Information about new messages will also be sent there
// Viber periodically knocks on the Webhook address, so if it is inactive, everything will stop working
//
//
// Parameters:
// Token - String - Viber Token - token
// URL - String - URL for setting up Webhook - url
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SetWebhook(Val Token, Val URL) Export
Parameters = New Structure;
OPI_Tools.AddField("url" , URL , "String", Parameters);
OPI_Tools.AddField("url" , URL , "String", Parameters);
OPI_Tools.AddField("auth_token" , Token, "String", Parameters);
Return OPI_Tools.Post("https://chatapi.viber.com/pa/set_webhook", Parameters);
EndFunction
// Get channel information
// Here you can get the channel's user IDs. Bot IDs need to be obtained from the Webhook arrivals
// The user ID from channel information is not suitable for sending messages through the bot - they are different
//
//
// Parameters:
// Token - String - Token - token
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function GetChannelInformation(Val Token) Export
URL = "https://chatapi.viber.com/pa/get_account_info";
URL = "https://chatapi.viber.com/pa/get_account_info";
Return OPI_Tools.Get(URL, , TokenInHeaders(Token));
EndFunction
// Get user data
// Gets user information by ID
//
//
// Parameters:
// Token - String - Token - token
// UserID - String, Number - Viber User ID - user
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function GetUserData(Val Token, Val UserID) Export
URL = "https://chatapi.viber.com/pa/get_user_details";
Parameters = New Structure;
OPI_Tools.AddField("id", UserID, "String", Parameters);
Response = OPI_Tools.Post(URL, Parameters, TokenInHeaders(Token));
Return Response;
@ -103,22 +103,22 @@ EndFunction
// Get online users
// Gets the status of a user or multiple users by ID
//
//
// Parameters:
// Token - String - Viber Token - token
// UserIDs - String,Number,Array of String,Number - Viber User(s) ID - users
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function GetOnlineUsers(Val Token, Val UserIDs) Export
URL = "https://chatapi.viber.com/pa/get_online";
Parameters = New Structure;
OPI_Tools.AddField("ids", UserIDs, "Collection", Parameters);
Response = OPI_Tools.Post(URL, Parameters, TokenInHeaders(Token));
Return Response;
EndFunction
@ -129,14 +129,14 @@ EndFunction
// Send text message
// Sends a text message to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// Text - String - Message text - text
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - Boolean - Sending to channel or bot chat - ischannel
// Keyboard - Structure Of String - See CreateKeyboardFromArrayButton - keyboard
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendTextMessage(Val Token
@ -144,40 +144,40 @@ Function SendTextMessage(Val Token
, Val UserID
, Val SendingToChannel
, Val Keyboard = "") Export
Return SendMessage(Token, "text", UserID, SendingToChannel, , Text, Keyboard);
Return SendMessage(Token, "text", UserID, SendingToChannel, , Text, Keyboard);
EndFunction
// Send image
// Sends an image to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// URL - String - Image URL - picture
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - boolean - Sending to channel or bot chat - ischannel
// Description - String - Image annotation - description
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendImage(Val Token, Val URL, Val UserID, Val SendingToChannel, Val Description = "") Export
Return SendMessage(Token, "picture", UserID, SendingToChannel, URL, Description);
EndFunction
// SendFile
// Sends a file (document) to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// URL - String - File URL - file
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// URL - String - File URL - file
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - Boolean - Sending to channel or bot chat - ischannel
// Extension - String - File extension - ext
// Size - Number - File size. If not filled in > determined automatically by downloading the file - size
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendFile(Val Token
@ -186,36 +186,36 @@ Function SendFile(Val Token
, Val SendingToChannel
, Val Extension
, Val Size = "") Export
If Not ValueIsFilled(Size) Then
Response = OPI_Tools.Get(URL);
Size = Response.Size();
Size = Response.Size();
EndIf;
String_ = "String";
String_ = "String";
Extension = StrReplace(Extension, ".", "");
Parameters = New Structure;
OPI_Tools.AddField("URL" , URL , String_, Parameters);
OPI_Tools.AddField("Size" , Size , String_, Parameters);
OPI_Tools.AddField("URL" , URL , String_, Parameters);
OPI_Tools.AddField("Size" , Size , String_, Parameters);
OPI_Tools.AddField("Extension", Extension, String_, Parameters);
Return SendMessage(Token, "file", UserID, SendingToChannel, Parameters);
EndFunction
// Send contact
// Sends a contact with a phone number to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// ContactName - String - Contact name - name
// PhoneNumber - String - Phone number - phone
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - Boolean - Sending to channel or bot chat - ischannel
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendContact(Val Token
@ -223,91 +223,91 @@ Function SendContact(Val Token
, Val PhoneNumber
, Val UserID
, Val SendingToChannel) Export
Parameters = New Structure;
OPI_Tools.AddField("name" , ContactName , "String", Parameters);
OPI_Tools.AddField("phone_number", PhoneNumber, "String", Parameters);
Return SendMessage(Token, "contact", UserID, SendingToChannel, Parameters);
OPI_Tools.AddField("name" , ContactName , "String", Parameters);
OPI_Tools.AddField("phone_number", PhoneNumber , "String", Parameters);
Return SendMessage(Token, "contact", UserID, SendingToChannel, Parameters);
EndFunction
// Send location
// Sends geographic coordinates to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// Latitude - String, Number - Geographic latitude - lat
// Longitude - String, Number - Geographic longitude - long
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - Boolean - Sending to channel or bot chat - ischannel
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendLocation(Val Token, Val Latitude, Val Longitude, Val UserID, Val SendingToChannel) Export
Parameters = New Structure;
OPI_Tools.AddField("lat", Latitude , "String", Parameters);
OPI_Tools.AddField("lon", Longitude, "String", Parameters);
Return SendMessage(Token, "location", UserID, SendingToChannel, Parameters);
EndFunction
// Send link
// Sends a URL with a preview to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// URL - String - SentLink - url
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - Boolean - Sending to channel or bot chat - ischannel
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendLink(Val Token, Val URL, Val UserID, Val SendingToChannel) Export
Return SendMessage(Token, "url", UserID, SendingToChannel, URL);
EndFunction
// Create a keyboard from an array of buttons
// Returns a keyboard structure for messages
//
//
// Parameters:
// ButtonArray - Array of String - Array of buttons - buttons
// ButtonColor - String - HEX color of buttons with # at the beginning - color
//
//
// Returns:
// Structure - Create a keyboard from an array of buttons:
// * Buttons - Array of Structure - Array of formed buttons
// * Type - String - KeyboardType
// * Buttons - Array of Structure - Array of formed buttons
// * Type - String - KeyboardType
Function CreateKeyboardFromArrayButton(Val ButtonArray, Val ButtonColor = "#2db9b9") Export
OPI_TypeConversion.GetLine(ButtonColor);
OPI_TypeConversion.GetCollection(ButtonArray);
ArrayOfButtonStructures = New Array;
KeyboardStructure = New Structure;
KeyboardStructure = New Structure;
For Each ButtonText In ButtonArray Do
ButtonStructure = New Structure;
ButtonStructure.Insert("ActionType", "reply");
ButtonStructure.Insert("ActionBody", ButtonText);
ButtonStructure.Insert("Text" , ButtonText);
ButtonStructure.Insert("BgColor" , ButtonColor);
ButtonStructure.Insert("Coloumns" , 3);
ButtonStructure.Insert("Text" , ButtonText);
ButtonStructure.Insert("BgColor" , ButtonColor);
ButtonStructure.Insert("Coloumns" , 3);
ArrayOfButtonStructures.Add(ButtonStructure);
EndDo;
KeyboardStructure.Insert("Buttons", ArrayOfButtonStructures);
KeyboardStructure.Insert("Type" , "keyboard");
KeyboardStructure.Insert("Type" , "keyboard");
Return KeyboardStructure;
EndFunction
#EndRegion
@ -317,7 +317,7 @@ EndFunction
#Region Private
// Send message.
//
//
// Parameters:
// Token - String - Token
// Type - String - TypeOfSentMessage
@ -328,8 +328,8 @@ EndFunction
// * Size - Number, String - File size in case of sending
// * Extension - String - File extension in case of sending
// Text - String - Message text
// Keyboard - Structure Of String - Keyboard, if needed, see CreateKeyboardFromArrayButton
//
// Keyboard - Structure Of String - Keyboard, if needed, see CreateKeyboardFromArrayButton
//
// Returns:
// Arbitrary, HTTPResponse - Send message
Function SendMessage(Val Token
@ -339,81 +339,81 @@ Function SendMessage(Val Token
, Val Value = ""
, Val Text = ""
, Val Keyboard = "")
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Type);
OPI_TypeConversion.GetLine(UserID);
OPI_TypeConversion.GetLine(Text);
OPI_TypeConversion.GetBoolean(IsChannel);
OPI_TypeConversion.GetCollection(Keyboard);
ParametersStructure = ReturnStandardParameters();
ParametersStructure.Insert("type", Type);
ParametersStructure.Insert("type", Type);
If (Type = "text" Or Type = "picture") And ValueIsFilled(Text) Then
ParametersStructure.Insert("text", Text);
EndIf;
If TypeOf(Keyboard) = Type("Structure") Then
ParametersStructure.Insert("keyboard", Keyboard);
EndIf;
If ValueIsFilled(Value) Then
If Type = "file" Then
ParametersStructure.Insert("media" , Value["URL"]);
ParametersStructure.Insert("size" , Value["Size"]);
If Type = "file" Then
ParametersStructure.Insert("media" , Value["URL"]);
ParametersStructure.Insert("size" , Value["Size"]);
ParametersStructure.Insert("file_name", "File." + Value["Extension"]);
ElsIf Type = "contact" Then
ParametersStructure.Insert("contact" , Value);
ParametersStructure.Insert("contact" , Value);
ElsIf Type = "location" Then
ParametersStructure.Insert("location" , Value);
Else
ParametersStructure.Insert("media" , Value);
ParametersStructure.Insert("media" , Value);
EndIf;
EndIf;
If IsChannel Then
ParametersStructure.Insert("from", UserID);
ParametersStructure.Insert("from" , UserID);
URL = "https://chatapi.viber.com/pa/post";
Else
Else
ParametersStructure.Insert("receiver", UserID);
URL = "https://chatapi.viber.com/pa/send_message";
EndIf;
Response = OPI_Tools.Post(URL, ParametersStructure, TokenInHeaders(Token));
Try
Return OPI_Tools.JsonToStructure(Response.ПолучитьТелоКакДвоичныеДанные());
Except
Return Response;
EndTry;
EndFunction
Function ReturnStandardParameters()
Function ReturnStandardParameters()
SenderStructure = New Structure;
SenderStructure.Insert("name" , "Bot");
SenderStructure.Insert("name" , "Bot");
SenderStructure.Insert("avatar", "");
ParametersStructure = New Structure;
ParametersStructure.Insert("sender", SenderStructure);
ParametersStructure.Insert("sender" , SenderStructure);
ParametersStructure.Insert("min_api_version", 1);
Return ParametersStructure;
EndFunction
Function TokenInHeaders(Val Token)
OPI_TypeConversion.GetLine(Token);
HeadersStructure = New Map;
HeadersStructure.Insert("X-Viber-Auth-Token", Token);
Return HeadersStructure;
EndFunction
#EndRegion

432
src/en/OInt/core/Modules/OPI_YandexDisk.os
View File

@ -37,7 +37,7 @@
//@skip-check wrong-string-literal-content
// Uncomment if OneScript is executed
#Use "../../tools"
#Use "../../tools"
#Region Public
@ -45,217 +45,217 @@
// Get disk information
// Gets information about the current disk
//
//
// Parameters:
// Token - String - Token - token
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetDiskInformation(Val Token) Export
OPI_TypeConversion.GetLine(Token);
Headers = AuthorizationHeader(Token);
Headers = AuthorizationHeader(Token);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk", , Headers);
Return Response;
EndFunction
// Create folder
// Creates a directory on the disk
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the created folder - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function CreateFolder(Val Token, Val Path) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
Headers = AuthorizationHeader(Token);
URL = "https://cloud-api.yandex.net/v1/disk/resources";
Href = "href";
URL = "https://cloud-api.yandex.net/v1/disk/resources";
Href = "href";
Parameters = New Structure;
Parameters.Insert("path", Path);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Put(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Put(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
If Not ValueIsFilled(ResponseURL) Then
Return Response;
Return Response;
EndIf;
Response = OPI_Tools.Get(ResponseURL, , Headers);
Return Response;
EndFunction
// Get object
// Gets information about a disk object at the specified path
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to folder or file - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetObject(Val Token, Val Path) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
Headers = AuthorizationHeader(Token);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
Parameters.Insert("path", Path);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/resources", Parameters, Headers);
Return Response;
EndFunction
// Delete object
// Deletes an object at the specified path
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the folder or file to be deleted - path
// ToCart - Boolean - To cart - can
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function DeleteObject(Val Token, Val Path, Val ToCart = True) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetBoolean(ToCart);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
Parameters.Insert("path" , Path);
Parameters.Insert("path" , Path);
Parameters.Insert("permanently", Not ToCart);
Response = OPI_Tools.Delete("https://cloud-api.yandex.net/v1/disk/resources", Parameters, Headers);
Return Response;
EndFunction
// Create object copy
// Creates a copy of the object at the specified path and path to the original
//
//
// Parameters:
// Token - String - Token - token
// Original - String - Path to the original file or directory - from
// Path - String - Destination path for the copy - to
// Overwrite - Boolean - Overwrite if a file with the same name already exists - rewrite
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function CreateObjectCopy(Val Token, Val Original, Val Path, Val Overwrite = False) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Original);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetBoolean(Overwrite);
Headers = AuthorizationHeader(Token);
URL = "https://cloud-api.yandex.net/v1/disk/resources/copy";
Href = "href";
URL = "https://cloud-api.yandex.net/v1/disk/resources/copy";
Href = "href";
Parameters = New Structure;
Parameters.Insert("from" , Original);
Parameters.Insert("path" , Path);
Parameters.Insert("from" , Original);
Parameters.Insert("path" , Path);
Parameters.Insert("overwrite" , Overwrite);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
If Not ValueIsFilled(ResponseURL) Then
Return Response;
Return Response;
EndIf;
Response = OPI_Tools.Get(ResponseURL, , Headers);
Return Response;
EndFunction
// Get download link
// Gets a download link for the file
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the file for downloading - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetDownloadLink(Val Token, Val Path) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
Parameters.Insert("path", Path);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/resources/download", Parameters, Headers);
Return Response;
EndFunction
// Download file
// Downloads a file at the specified path
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the file for downloading - path
// SavePath - String - File save path - out
//
// SavePath - String - File save path - out
//
// Returns:
// BinaryData,String - Binary data or file path when SavePath parameter is specified
Function DownloadFile(Val Token, Val Path, Val SavePath = "") Export
OPI_TypeConversion.GetLine(SavePath);
Response = GetDownloadLink(Token, Path);
URL = Response["href"];
URL = Response["href"];
If Not ValueIsFilled(URL) Then
Return Response;
EndIf;
Response = OPI_Tools.Get(URL, , , SavePath);
Return Response;
EndFunction
// Get list of files
// Gets a list of files with or without filtering by type
// List of available types: audio, backup, book, compressed, data, development,
// diskimage, document, encoded, executable, flash, font,
// List of available types: audio, backup, book, compressed, data, development,
// diskimage, document, encoded, executable, flash, font,
// mage, settings, spreadsheet, text, unknown, video, web
//
//
// Parameters:
// Token - String - Token - token
// Count - Number, String - Number of returned objects - amount
// OffsetFromStart - Number - Offset for getting objects not from the beginning of the list - offset
// FilterByType - String - Filter by file type - type
// SortByDate - Boolean - True > sort by date, False > alphabetically - datesort
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetFilesList(Val Token
@ -263,50 +263,50 @@ Function GetFilesList(Val Token
, Val OffsetFromStart = 0
, Val FilterByType = ""
, Val SortByDate = False) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Count);
OPI_TypeConversion.GetLine(OffsetFromStart);
OPI_TypeConversion.GetLine(FilterByType);
OPI_TypeConversion.GetBoolean(SortByDate);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
If ValueIsFilled(Count) Then
Parameters.Insert("limit", OPI_Tools.NumberToString(Count));
EndIf;
If ValueIsFilled(OffsetFromStart) Then
Parameters.Insert("offset", OPI_Tools.NumberToString(OffsetFromStart));
EndIf;
If ValueIsFilled(FilterByType) Then
Parameters.Insert("media_type", FilterByType);
EndIf;
If SortByDate Then
Destination = "last-uploaded";
Else
Destination = "files";
EndIf;
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/resources/" + Destination, Parameters, Headers);
Return Response;
EndFunction
// Move object
// Moves the object to the specified path and path to the original
//
//
// Parameters:
// Token - String - Token - token
// Original - String - Path to the original file or folder - from
// Path - String - Destination path for moving - to
// Overwrite - Boolean - Overwrite if a file with the same name already exists - rewrite
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function MoveObject(Val Token, Val Original, Val Path, Val Overwrite = False) Export
@ -315,97 +315,97 @@ Function MoveObject(Val Token, Val Original, Val Path, Val Overwrite = False) Ex
OPI_TypeConversion.GetLine(Original);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetBoolean(Overwrite);
Headers = AuthorizationHeader(Token);
URL = "https://cloud-api.yandex.net/v1/disk/resources/move";
Href = "href";
URL = "https://cloud-api.yandex.net/v1/disk/resources/move";
Href = "href";
Parameters = New Structure;
Parameters.Insert("from" , Original);
Parameters.Insert("path" , Path);
Parameters.Insert("from" , Original);
Parameters.Insert("path" , Path);
Parameters.Insert("overwrite" , Overwrite);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
If Not ValueIsFilled(ResponseURL) Then
Return Response;
Return Response;
EndIf;
Response = OPI_Tools.Get(ResponseURL, , Headers);
Return Response;
EndFunction
// Upload file
// Uploads a file to disk at the specified path
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path for saving the file to disk - path
// File - String, BinaryData - File for upload - file
// Overwrite - Boolean - Overwrite if a file with the same name already exists - rewrite
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
// Map Of KeyAndValue - serialized JSON response from Yandex
Function UploadFile(Val Token, Val Path, Val File, Val Overwrite = False) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetBoolean(Overwrite);
OPI_TypeConversion.GetBinaryData(File);
Headers = AuthorizationHeader(Token);
Href = "href";
File = New Structure("file", File);
Href = "href";
File = New Structure("file", File);
Parameters = New Structure;
Parameters.Insert("path" , Path);
Parameters.Insert("path" , Path);
Parameters.Insert("overwrite" , Overwrite);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/resources/upload", Parameters, Headers);
URL = Response[Href];
URL = Response[Href];
If Not ValueIsFilled(URL) Then
Return Response;
Return Response;
EndIf;
Response = OPI_Tools.PutMultipart(URL, New Structure(), File, "multipart", Headers);
Return Response;
EndFunction
// Upload file by URL
// Downloads a file to disk from the specified URL
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to place the downloaded file - path
// Address - String - File URL - url
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function UploadFileByURL(Val Token, Val Path, Val Address) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetLine(Address);
Headers = AuthorizationHeader(Token);
URL = "https://cloud-api.yandex.net/v1/disk/resources/upload";
URL = "https://cloud-api.yandex.net/v1/disk/resources/upload";
Parameters = New Structure;
Parameters.Insert("url" , EncodeString(Address, StringEncodingMethod.URLencoding));
Parameters.Insert("path", Path);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
Return Response;
EndFunction
#EndRegion
@ -414,186 +414,186 @@ EndFunction
// Publish object
// Publishes the disk object for public access
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the object to be published - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
// Map Of KeyAndValue - serialized JSON response from Yandex
Function PublishObject(Val Token, Val Path) Export
Return TogglePublicAccess(Token, Path, True);
Return TogglePublicAccess(Token, Path, True);
EndFunction
// Unpublish object
// Unpublishes a previously published object
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the previously published object - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function CancelObjectPublication(Val Token, Val Path) Export
Return TogglePublicAccess(Token, Path, False);
EndFunction
// Get list of published objects.
// Gets a list of published objects
//
//
// Parameters:
// Token - String - Token - token
// Token - String - Token - token
// Count - Number - Number of returned objects - amount
// OffsetFromStart - Number - Offset for getting objects not from the beginning of the list - offset
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetPublishedObjectsList(Val Token, Val Count = 0, Val OffsetFromStart = 0) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Count);
OPI_TypeConversion.GetLine(OffsetFromStart);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
If ValueIsFilled(Count) Then
Parameters.Insert("limit", Count);
EndIf;
If ValueIsFilled(OffsetFromStart) Then
Parameters.Insert("offset", OffsetFromStart);
EndIf;
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/resources/public", Parameters, Headers);
Return Response;
EndFunction
// Get public object
// Gets information about the published object by its URL
//
//
// Parameters:
// Token - String - Token - token
// URL - String - Object address - url
// URL - String - Object address - url
// Count - Number - Number of returned nested objects (for catalog) - amount
// OffsetFromStart - Number - Offset for getting nested objects not from the beginning of the list - offset
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetPublicObject(Val Token, Val URL, Val Count = 0, Val OffsetFromStart = 0) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(URL);
OPI_TypeConversion.GetLine(Count);
OPI_TypeConversion.GetLine(OffsetFromStart);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
If ValueIsFilled(Count) Then
Parameters.Insert("limit", OPI_Tools.NumberToString(Count));
EndIf;
If ValueIsFilled(OffsetFromStart) Then
Parameters.Insert("offset", OPI_Tools.NumberToString(OffsetFromStart));
EndIf;
Parameters.Insert("public_key", URL);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/public/resources", Parameters, Headers);
Return Response;
EndFunction
// Get download link for public object
// Gets a direct link to download the public object
//
//
// Parameters:
// Token - String - Token - token
// URL - String - Object address - url
// Path - String - Path inside the object - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetDownloadLinkForPublicObject(Val Token, Val URL, Val Path = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(URL);
OPI_TypeConversion.GetLine(Path);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
If ValueIsFilled(Path) Then
Parameters.Insert("path", Path);
EndIf;
Parameters.Insert("public_key", URL);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/public/resources/download", Parameters, Headers);
Return Response;
Return Response;
EndFunction
// Save public object to disk
// Saves the public object to your disk
//
//
// Parameters:
// Token - String - Token - token
// URL - String - Object address - url
// From - String - Path within public catalog (folders only) - from
// Target - String - File save path - to
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function SavePublicObjectToDisk(Val Token, Val URL, From = "", Target = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(URL);
OPI_TypeConversion.GetLine(From);
OPI_TypeConversion.GetLine(Target);
Headers = AuthorizationHeader(Token);
Address = "https://cloud-api.yandex.net/v1/disk/public/resources/save-to-disk";
Href = "href";
Href = "href";
Parameters = New Structure;
Parameters.Insert("public_key", EncodeString(URL, StringEncodingMethod.URLencoding));
If ValueIsFilled(From) Then
Parameters.Insert("path", From);
EndIf;
If ValueIsFilled(Target) Then
Parameters.Insert("save_path", Target);
EndIf;
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(Address + Parameters, , Headers, False);
ResponseURL = Response[Href];
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(Address + Parameters, , Headers, False);
ResponseURL = Response[Href];
If Not ValueIsFilled(ResponseURL) Then
Return Response;
Return Response;
EndIf;
Response = OPI_Tools.Get(ResponseURL, , Headers);
Return Response;
EndFunction
#EndRegion
#EndRegion
@ -601,42 +601,42 @@ EndFunction
#Region Private
Function AuthorizationHeader(Val Token)
Headers = New Map;
Headers.Insert("Authorization", "OAuth " + Token);
Return Headers;
EndFunction
Function TogglePublicAccess(Val Token, Val Path, Val PublicAccess)
Function TogglePublicAccess(Val Token, Val Path, Val PublicAccess)
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetBoolean(PublicAccess);
Headers = AuthorizationHeader(Token);
Headers = AuthorizationHeader(Token);
Destination = ?(PublicAccess, "publish", "unpublish");
Href = "href";
Href = "href";
URL = "https://cloud-api.yandex.net/v1/disk/resources/" + Destination;
Parameters = New Structure;
Parameters.Insert("path", Path);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Put(URL + Parameters, , Headers, False);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Put(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
If Not ValueIsFilled(ResponseURL) Then
Return Response;
EndIf;
Return Response;
EndIf;
Response = OPI_Tools.Get(ResponseURL, , Headers);
Return Response;
EndFunction
#EndRegion

50
src/en/OInt/core/Modules/OPI_YandexID.os
View File

@ -41,77 +41,77 @@
// Get confirmation code
// Gets the confirmation code and the address of the page where it needs to be entered
//
//
// Parameters:
// ClientId - String - Client id - id
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetConfirmationCode(Val ClientId) Export
OPI_TypeConversion.GetLine(ClientId);
Parameters = New Structure("client_id", ClientId);
Response = OPI_Tools.Post("https://oauth.yandex.ru/device/code", Parameters, , False);
Response = OPI_Tools.Post("https://oauth.yandex.ru/device/code", Parameters, , False);
Return Response;
EndFunction
// Convert code to token
// Converts the code to a token after entering the code when executing GetConfirmationCode
//
//
// Parameters:
// ClientId - String - Client id - id
// ClientSecret - String - Client secret - secret
// DeviceCode - String - device_code from GetConfirmationCode() - device
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function ConvertCodeToToken(Val ClientId, Val ClientSecret, Val DeviceCode) Export
OPI_TypeConversion.GetLine(ClientId);
OPI_TypeConversion.GetLine(ClientSecret);
OPI_TypeConversion.GetLine(DeviceCode);
Parameters = New Structure;
Parameters.Insert("grant_type" , "device_code");
Parameters.Insert("code" , DeviceCode);
Parameters.Insert("client_id" , ClientId);
Parameters.Insert("grant_type" , "device_code");
Parameters.Insert("code" , DeviceCode);
Parameters.Insert("client_id" , ClientId);
Parameters.Insert("client_secret" , ClientSecret);
Response = OPI_Tools.Post("https://oauth.yandex.ru/token", Parameters, , False);
Return Response;
EndFunction
// Refresh token
// Updates token by Refresh token
//
//
// Parameters:
// ClientId - String - Client id - id
// ClientSecret - String - Client secret - secret
// RefreshToken - String - Refresh token - refresh
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function RefreshToken(Val ClientId, Val ClientSecret, Val RefreshToken) Export
OPI_TypeConversion.GetLine(ClientId);
OPI_TypeConversion.GetLine(ClientSecret);
OPI_TypeConversion.GetLine(RefreshToken);
Parameters = New Structure;
Parameters.Insert("grant_type" , "refresh_token");
Parameters.Insert("grant_type" , "refresh_token");
Parameters.Insert("refresh_token" , RefreshToken);
Parameters.Insert("client_id" , ClientId);
Parameters.Insert("client_id" , ClientId);
Parameters.Insert("client_secret" , ClientSecret);
Response = OPI_Tools.Post("https://oauth.yandex.ru/token", Parameters, , False);
Return Response;
EndFunction
#EndRegion

8520
src/en/OInt/tests/Modules/internal/OPI_Tests.os
View File

File diff suppressed because it is too large Load Diff

518
src/en/OInt/tools/Modules/OPI_TestDataRetrieval.os
View File

@ -46,404 +46,404 @@
#Region Internal
Function GetTestingSectionMapping() Export
StandardDependencies = "[Decode, Build]";
GoogleDependencies = "Testing-GoogleWorkspace";
GoogleDependencies = "Testing-GoogleWorkspace";
Sections = New Structure;
Sections.Insert("Telegram" , StandardDependencies);
Sections.Insert("VK" , StandardDependencies);
Sections.Insert("Viber" , StandardDependencies);
Sections.Insert("Twitter" , StandardDependencies);
Sections.Insert("YandexDisk" , StandardDependencies);
Sections.Insert("Telegram" , StandardDependencies);
Sections.Insert("VK" , StandardDependencies);
Sections.Insert("Viber" , StandardDependencies);
Sections.Insert("Twitter" , StandardDependencies);
Sections.Insert("YandexDisk" , StandardDependencies);
Sections.Insert("GoogleWorkspace", StandardDependencies);
Sections.Insert("GoogleCalendar" , GoogleDependencies);
Sections.Insert("GoogleDrive" , GoogleDependencies);
Sections.Insert("GoogleSheets" , GoogleDependencies);
Sections.Insert("Notion" , StandardDependencies);
Sections.Insert("Slack" , StandardDependencies);
Sections.Insert("Airtable" , StandardDependencies);
Sections.Insert("Dropbox" , StandardDependencies);
Sections.Insert("Bitrix24" , StandardDependencies);
Sections.Insert("GoogleCalendar" , GoogleDependencies);
Sections.Insert("GoogleDrive" , GoogleDependencies);
Sections.Insert("GoogleSheets" , GoogleDependencies);
Sections.Insert("Notion" , StandardDependencies);
Sections.Insert("Slack" , StandardDependencies);
Sections.Insert("Airtable" , StandardDependencies);
Sections.Insert("Dropbox" , StandardDependencies);
Sections.Insert("Bitrix24" , StandardDependencies);
Return Sections;
EndFunction
Function GetTestTable() Export
Telegram = "Telegram";
Telegram = "Telegram";
VKontakte = "VK";
YDisk = "YandexDisk";
Calendar = "GoogleCalendar";
Twitter = "Twitter";
Viber = "Viber";
Drive = "GoogleDrive";
VSpace = "GoogleWorkspace";
Notion = "Notion";
Slack = "Slack";
Tables = "GoogleSheets";
AirT = "Airtable";
Dropbox = "Dropbox";
Bitrix = "Bitrix24";
YDisk = "YandexDisk";
Calendar = "GoogleCalendar";
Twitter = "Twitter";
Viber = "Viber";
Drive = "GoogleDrive";
VSpace = "GoogleWorkspace";
Notion = "Notion";
Slack = "Slack";
Tables = "GoogleSheets";
AirT = "Airtable";
Dropbox = "Dropbox";
Bitrix = "Bitrix24";
TestTable = New ValueTable;
TestTable.Columns.Add("Method");
TestTable.Columns.Add("Synonym");
TestTable.Columns.Add("Section");
NewTest(TestTable, "TelegramAPI_GetBotInfo" , "Get bot information" , Telegram);
NewTest(TestTable, "TelegramAPI_GetUpdates" , "Get updates" , Telegram);
NewTest(TestTable, "TelegramAPI_SetWebhook" , "Set Webhook" , Telegram);
NewTest(TestTable, "TelegramAPI_SendTextMessage" , "Send text message" , Telegram);
NewTest(TestTable, "TelegramAPI_SendImage" , "Send image" , Telegram);
NewTest(TestTable, "TelegramAPI_SendVideo" , "Send video" , Telegram);
NewTest(TestTable, "TelegramAPI_SendAudio" , "Send audio" , Telegram);
NewTest(TestTable, "TelegramAPI_SendDocument" , "Send document" , Telegram);
NewTest(TestTable, "TelegramAPI_SendGIF" , "Send GIF" , Telegram);
NewTest(TestTable, "TelegramAPI_SendMediaGroup" , "Send mediagroup" , Telegram);
NewTest(TestTable, "TelegramAPI_SendLocation" , "Send location" , Telegram);
NewTest(TestTable, "TelegramAPI_SendContact" , "Send contact" , Telegram);
NewTest(TestTable, "TelegramAPI_SendPoll" , "Send poll" , Telegram);
NewTest(TestTable, "TelegramAPI_ForwardMessage" , "Forward message" , Telegram);
NewTest(TestTable, "TelegramAPI_BanUnban" , "Ban/Unban" , Telegram);
NewTest(TestTable, "TelegramAPI_CreateInvitationLink" , "Create invitation link" , Telegram);
NewTest(TestTable, "TelegramAPI_PinUnpinMessage" , "Pin/Unpin message" , Telegram);
NewTest(TestTable, "TelegramAPI_GetMemberCount" , "Get participant count" , Telegram);
NewTest(TestTable, "TelegramAPI_GetForumAvatarsList", "Get forum avatars list", Telegram);
NewTest(TestTable, "TelegramAPI_GetBotInfo" , "Get bot information" , Telegram);
NewTest(TestTable, "TelegramAPI_GetUpdates" , "Get updates" , Telegram);
NewTest(TestTable, "TelegramAPI_SetWebhook" , "Set Webhook" , Telegram);
NewTest(TestTable, "TelegramAPI_SendTextMessage" , "Send text message" , Telegram);
NewTest(TestTable, "TelegramAPI_SendImage" , "Send image" , Telegram);
NewTest(TestTable, "TelegramAPI_SendVideo" , "Send video" , Telegram);
NewTest(TestTable, "TelegramAPI_SendAudio" , "Send audio" , Telegram);
NewTest(TestTable, "TelegramAPI_SendDocument" , "Send document" , Telegram);
NewTest(TestTable, "TelegramAPI_SendGIF" , "Send GIF" , Telegram);
NewTest(TestTable, "TelegramAPI_SendMediaGroup" , "Send mediagroup" , Telegram);
NewTest(TestTable, "TelegramAPI_SendLocation" , "Send location" , Telegram);
NewTest(TestTable, "TelegramAPI_SendContact" , "Send contact" , Telegram);
NewTest(TestTable, "TelegramAPI_SendPoll" , "Send poll" , Telegram);
NewTest(TestTable, "TelegramAPI_ForwardMessage" , "Forward message" , Telegram);
NewTest(TestTable, "TelegramAPI_BanUnban" , "Ban/Unban" , Telegram);
NewTest(TestTable, "TelegramAPI_CreateInvitationLink" , "Create invitation link" , Telegram);
NewTest(TestTable, "TelegramAPI_PinUnpinMessage" , "Pin/Unpin message" , Telegram);
NewTest(TestTable, "TelegramAPI_GetMemberCount" , "Get participant count" , Telegram);
NewTest(TestTable, "TelegramAPI_GetForumAvatarsList" , "Get forum avatars list" , Telegram);
NewTest(TestTable, "TelegramAPI_CreateDeleteForumTopic" , "Create/Delete forum topic" , Telegram);
NewTest(TestTable, "TelegramAPI_ChangeMainTopicName" , "Change main topic name" , Telegram);
NewTest(TestTable, "TelegramAPI_HideShowMainTopic" , "Hide/Show main topic" , Telegram);
NewTest(TestTable, "VKAPI_CreateTokenLink" , "Create token retrieval link", VKontakte);
NewTest(TestTable, "VKAPI_CreateDeletePost" , "Create/Delete post" , VKontakte);
NewTest(TestTable, "VKAPI_CreateCompositePost" , "Create/Delete composite post" , VKontakte);
NewTest(TestTable, "VKAPI_CreatePoll" , "Create poll" , VKontakte);
NewTest(TestTable, "VKAPI_SaveDeleteImage" , "Add/Delete image" , VKontakte);
NewTest(TestTable, "VKAPI_CreateStory" , "Create story" , VKontakte);
NewTest(TestTable, "VKAPI_DiscussionMethods" , "Actions with discussions" , VKontakte);
NewTest(TestTable, "VKAPI_LikeRepostComment" , "Like/Repost/Comment" , VKontakte);
NewTest(TestTable, "VKAPI_GetStatistics" , "Get statistics" , VKontakte);
NewTest(TestTable, "VKAPI_GetPostStatistics" , "Get post statistics" , VKontakte);
NewTest(TestTable, "VKAPI_CreateAdCampaign" , "Create advertising campaign" , VKontakte);
NewTest(TestTable, "VKAPI_SendMessage" , "Send message" , VKontakte);
NewTest(TestTable, "VKAPI_GetProductCategories" , "Get product categories" , VKontakte);
NewTest(TestTable, "VKAPI_CreateProductSelection" , "Create product and selection" , VKontakte);
NewTest(TestTable, "TelegramAPI_ChangeMainTopicName" , "Change main topic name" , Telegram);
NewTest(TestTable, "TelegramAPI_HideShowMainTopic" , "Hide/Show main topic" , Telegram);
NewTest(TestTable, "VKAPI_CreateTokenLink" , "Create token retrieval link" , VKontakte);
NewTest(TestTable, "VKAPI_CreateDeletePost" , "Create/Delete post" , VKontakte);
NewTest(TestTable, "VKAPI_CreateCompositePost" , "Create/Delete composite post" , VKontakte);
NewTest(TestTable, "VKAPI_CreatePoll" , "Create poll" , VKontakte);
NewTest(TestTable, "VKAPI_SaveDeleteImage" , "Add/Delete image" , VKontakte);
NewTest(TestTable, "VKAPI_CreateStory" , "Create story" , VKontakte);
NewTest(TestTable, "VKAPI_DiscussionMethods" , "Actions with discussions" , VKontakte);
NewTest(TestTable, "VKAPI_LikeRepostComment" , "Like/Repost/Comment" , VKontakte);
NewTest(TestTable, "VKAPI_GetStatistics" , "Get statistics" , VKontakte);
NewTest(TestTable, "VKAPI_GetPostStatistics" , "Get post statistics" , VKontakte);
NewTest(TestTable, "VKAPI_CreateAdCampaign" , "Create advertising campaign" , VKontakte);
NewTest(TestTable, "VKAPI_SendMessage" , "Send message" , VKontakte);
NewTest(TestTable, "VKAPI_GetProductCategories" , "Get product categories" , VKontakte);
NewTest(TestTable, "VKAPI_CreateProductSelection" , "Create product and selection" , VKontakte);
NewTest(TestTable, "VKAPI_CreateProductWithProperties" , "Create product with properties" , VKontakte);
NewTest(TestTable, "VKAPI_GetProductList" , "Get product list" , VKontakte);
NewTest(TestTable, "VKAPI_GetSelectionList" , "Get selection list" , VKontakte);
NewTest(TestTable, "VKAPI_GetPropertyList" , "Get property list" , VKontakte);
NewTest(TestTable, "VKAPI_GetOrderList" , "Get order list" , VKontakte);
NewTest(TestTable, "VKAPI_UploadVideo" , "Upload video" , VKontakte);
NewTest(TestTable, "YDisk_GetDiskInfo" , "Get disk information" , YDisk);
NewTest(TestTable, "YDisk_CreateFolder" , "Create folder" , YDisk);
NewTest(TestTable, "YDisk_UploadByUrlAndGetObject", "Upload by URL and get" , YDisk);
NewTest(TestTable, "YDisk_UploadDeleteFile" , "Upload/Delete file" , YDisk);
NewTest(TestTable, "YDisk_CreateObjectCopy" , "Create object copy" , YDisk);
NewTest(TestTable, "YDisk_GetDownloadLink" , "Get download link" , YDisk);
NewTest(TestTable, "YDisk_GetFileList" , "Get list of files" , YDisk);
NewTest(TestTable, "YDisk_MoveObject" , "Move object" , YDisk);
NewTest(TestTable, "YDisk_PublicObjectActions" , "Actions with public objects", YDisk);
NewTest(TestTable, "YDisk_GetPublishedList" , "Get published list" , YDisk);
NewTest(TestTable, "VKAPI_GetProductList" , "Get product list" , VKontakte);
NewTest(TestTable, "VKAPI_GetSelectionList" , "Get selection list" , VKontakte);
NewTest(TestTable, "VKAPI_GetPropertyList" , "Get property list" , VKontakte);
NewTest(TestTable, "VKAPI_GetOrderList" , "Get order list" , VKontakte);
NewTest(TestTable, "VKAPI_UploadVideo" , "Upload video" , VKontakte);
NewTest(TestTable, "YDisk_GetDiskInfo" , "Get disk information" , YDisk);
NewTest(TestTable, "YDisk_CreateFolder" , "Create folder" , YDisk);
NewTest(TestTable, "YDisk_UploadByUrlAndGetObject", "Upload by URL and get" , YDisk);
NewTest(TestTable, "YDisk_UploadDeleteFile" , "Upload/Delete file" , YDisk);
NewTest(TestTable, "YDisk_CreateObjectCopy" , "Create object copy" , YDisk);
NewTest(TestTable, "YDisk_GetDownloadLink" , "Get download link" , YDisk);
NewTest(TestTable, "YDisk_GetFileList" , "Get list of files" , YDisk);
NewTest(TestTable, "YDisk_MoveObject" , "Move object" , YDisk);
NewTest(TestTable, "YDisk_PublicObjectActions" , "Actions with public objects", YDisk);
NewTest(TestTable, "YDisk_GetPublishedList" , "Get published list" , YDisk);
NewTest(TestTable, "GV_GetAuthorizationLink" , "Get authorization link" , VSpace);
NewTest(TestTable, "GV_GetToken" , "Get token" , VSpace);
NewTest(TestTable, "GV_UpdateToken" , "Refresh token" , VSpace);
NewTest(TestTable, "GC_GetCalendarList" , "Get list of calendars" , Calendar);
NewTest(TestTable, "GV_GetToken" , "Get token" , VSpace);
NewTest(TestTable, "GV_UpdateToken" , "Refresh token" , VSpace);
NewTest(TestTable, "GC_GetCalendarList" , "Get list of calendars" , Calendar);
NewTest(TestTable, "GC_CreateDeleteCalendar" , "Create/Delete calendar" , Calendar);
NewTest(TestTable, "GC_CreateDeleteEvent" , "Create/Delete event" , Calendar);
NewTest(TestTable, "GC_GetEventList" , "Get list of events" , Calendar);
NewTest(TestTable, "GD_GetCatalogList" , "Get list of directories" , Drive);
NewTest(TestTable, "GD_UploadDeleteFile" , "Upload/Delete file" , Drive);
NewTest(TestTable, "GD_CreateDeleteComment" , "Create/Delete Comment" , Drive);
NewTest(TestTable, "GD_CreateCatalog" , "Create/Delete catalog" , Drive);
NewTest(TestTable, "GT_CreateTable" , "Create table" , Tables);
NewTest(TestTable, "GT_GetTable" , "Get table" , Tables);
NewTest(TestTable, "GC_CreateDeleteEvent" , "Create/Delete event" , Calendar);
NewTest(TestTable, "GC_GetEventList" , "Get list of events" , Calendar);
NewTest(TestTable, "GD_GetCatalogList" , "Get list of directories" , Drive);
NewTest(TestTable, "GD_UploadDeleteFile" , "Upload/Delete file" , Drive);
NewTest(TestTable, "GD_CreateDeleteComment" , "Create/Delete Comment" , Drive);
NewTest(TestTable, "GD_CreateCatalog" , "Create/Delete catalog" , Drive);
NewTest(TestTable, "GT_CreateTable" , "Create table" , Tables);
NewTest(TestTable, "GT_GetTable" , "Get table" , Tables);
NewTest(TestTable, "GT_FillClearCells" , "Fill/Clear cells" , Tables);
NewTest(TestTable, "Twitter_GetAuthorizationLink" , "Get authorization link" , Twitter);
NewTest(TestTable, "Twitter_UpdateToken" , "Refresh token" , Twitter);
NewTest(TestTable, "Twitter_CreateTextTweet" , "Text tweet" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithImage" , "Tweet with image" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithVideo" , "Tweet with video" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithGif" , "Tweet with gif" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithPoll" , "Tweet with poll" , Twitter);
NewTest(TestTable, "Viber_GetChannelInfo" , "Get channel info" , Viber);
NewTest(TestTable, "Viber_GetUserData" , "Get user data" , Viber);
NewTest(TestTable, "Viber_GetOnlineUsers" , "Get online users" , Viber);
NewTest(TestTable, "Twitter_UpdateToken" , "Refresh token" , Twitter);
NewTest(TestTable, "Twitter_CreateTextTweet" , "Text tweet" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithImage" , "Tweet with image" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithVideo" , "Tweet with video" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithGif" , "Tweet with gif" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithPoll" , "Tweet with poll" , Twitter);
NewTest(TestTable, "Viber_GetChannelInfo" , "Get channel info" , Viber);
NewTest(TestTable, "Viber_GetUserData" , "Get user data" , Viber);
NewTest(TestTable, "Viber_GetOnlineUsers" , "Get online users" , Viber);
NewTest(TestTable, "Viber_SendTextMessage" , "Send text message" , Viber);
NewTest(TestTable, "Viber_SendImage" , "Send image" , Viber);
NewTest(TestTable, "Viber_SendFile" , "SendFile" , Viber);
NewTest(TestTable, "Viber_SendContact" , "Send contact" , Viber);
NewTest(TestTable, "Viber_SendLocation" , "Send location" , Viber);
NewTest(TestTable, "Viber_SendLink" , "Send link" , Viber);
NewTest(TestTable, "Notion_CreatePage" , "Create page" , Notion);
NewTest(TestTable, "Notion_CreateEditDatabase" , "Create/Edit database" , Notion);
NewTest(TestTable, "Notion_GetPageInfo" , "Get page info" , Notion);
NewTest(TestTable, "Notion_GetDatabaseInfo" , "Get database info" , Notion);
NewTest(TestTable, "Viber_SendImage" , "Send image" , Viber);
NewTest(TestTable, "Viber_SendFile" , "SendFile" , Viber);
NewTest(TestTable, "Viber_SendContact" , "Send contact" , Viber);
NewTest(TestTable, "Viber_SendLocation" , "Send location" , Viber);
NewTest(TestTable, "Viber_SendLink" , "Send link" , Viber);
NewTest(TestTable, "Notion_CreatePage" , "Create page" , Notion);
NewTest(TestTable, "Notion_CreateEditDatabase" , "Create/Edit database" , Notion);
NewTest(TestTable, "Notion_GetPageInfo" , "Get page info" , Notion);
NewTest(TestTable, "Notion_GetDatabaseInfo" , "Get database info" , Notion);
NewTest(TestTable, "Notion_CreatePageInDatabase" , "Create page in database" , Notion);
NewTest(TestTable, "Notion_EditPageProperties" , "Edit page properties" , Notion);
NewTest(TestTable, "Notion_CreateDeleteBlock" , "Create/Delete block" , Notion);
NewTest(TestTable, "Notion_GetUsers" , "Get users" , Notion);
NewTest(TestTable, "Notion_GetUserData" , "Get user data" , Notion);
NewTest(TestTable, "Slack_GetBotInfo" , "Get bot information" , Slack);
NewTest(TestTable, "Slack_GetUserList" , "Get user list" , Slack);
NewTest(TestTable, "Slack_GetRegionList" , "Get region list" , Slack);
NewTest(TestTable, "Slack_SendDeleteMessage" , "Send/Delete message" , Slack);
NewTest(TestTable, "Slack_SendDeleteEphemeral" , "Send/Delete ephemeral" , Slack);
NewTest(TestTable, "Slack_GetScheduledMessages" , "Get scheduled messages" , Slack);
NewTest(TestTable, "Slack_CreateArchiveChannel" , "Create/Archive channel" , Slack);
NewTest(TestTable, "Slack_GetChannelList" , "Get channel list" , Slack);
NewTest(TestTable, "Slack_OpenCloseDialog" , "Open/Close dialog" , Slack);
NewTest(TestTable, "Slack_GetFileList" , "Get list of files" , Slack);
NewTest(TestTable, "Slack_UploadDeleteFile" , "Upload/Delete file" , Slack);
NewTest(TestTable, "Slack_GetExternalFileList" , "Get external file list" , Slack);
NewTest(TestTable, "Notion_EditPageProperties" , "Edit page properties" , Notion);
NewTest(TestTable, "Notion_CreateDeleteBlock" , "Create/Delete block" , Notion);
NewTest(TestTable, "Notion_GetUsers" , "Get users" , Notion);
NewTest(TestTable, "Notion_GetUserData" , "Get user data" , Notion);
NewTest(TestTable, "Slack_GetBotInfo" , "Get bot information" , Slack);
NewTest(TestTable, "Slack_GetUserList" , "Get user list" , Slack);
NewTest(TestTable, "Slack_GetRegionList" , "Get region list" , Slack);
NewTest(TestTable, "Slack_SendDeleteMessage" , "Send/Delete message" , Slack);
NewTest(TestTable, "Slack_SendDeleteEphemeral" , "Send/Delete ephemeral" , Slack);
NewTest(TestTable, "Slack_GetScheduledMessages" , "Get scheduled messages" , Slack);
NewTest(TestTable, "Slack_CreateArchiveChannel" , "Create/Archive channel" , Slack);
NewTest(TestTable, "Slack_GetChannelList" , "Get channel list" , Slack);
NewTest(TestTable, "Slack_OpenCloseDialog" , "Open/Close dialog" , Slack);
NewTest(TestTable, "Slack_GetFileList" , "Get list of files" , Slack);
NewTest(TestTable, "Slack_UploadDeleteFile" , "Upload/Delete file" , Slack);
NewTest(TestTable, "Slack_GetExternalFileList" , "Get external file list" , Slack);
NewTest(TestTable, "Slack_UploadDeleteExternalFile" , "Upload/Delete external file" , Slack);
NewTest(TestTable, "AT_CreateDatabase" , "Create/Edit database" , AirT);
NewTest(TestTable, "AT_CreateTable" , "Create/Edit table" , AirT);
NewTest(TestTable, "AT_CreateField" , "Create/Edit field" , AirT);
NewTest(TestTable, "AT_CreateDatabase" , "Create/Edit database" , AirT);
NewTest(TestTable, "AT_CreateTable" , "Create/Edit table" , AirT);
NewTest(TestTable, "AT_CreateField" , "Create/Edit field" , AirT);
NewTest(TestTable, "AT_CreateDeleteRecords" , "Create/Delete records" , AirT);
NewTest(TestTable, "DropboxAPI_GetUpdateToken" , "Get/Update token" , Dropbox);
NewTest(TestTable, "DropboxAPI_UploadFile" , "Upload file" , Dropbox);
NewTest(TestTable, "DropboxAPI_UploadFileByURL" , "Upload file by URL" , Dropbox);
NewTest(TestTable, "DropboxAPI_CreateFolder" , "Create folder" , Dropbox);
NewTest(TestTable, "DropboxAPI_CreateDeleteTag" , "Create/Delete tag" , Dropbox);
NewTest(TestTable, "DropboxAPI_GetAccount" , "Get account data" , Dropbox);
NewTest(TestTable, "DropboxAPI_AccessManagement" , "Access management" , Dropbox);
NewTest(TestTable, "DropboxAPI_GetUpdateToken" , "Get/Update token" , Dropbox);
NewTest(TestTable, "DropboxAPI_UploadFile" , "Upload file" , Dropbox);
NewTest(TestTable, "DropboxAPI_UploadFileByURL" , "Upload file by URL" , Dropbox);
NewTest(TestTable, "DropboxAPI_CreateFolder" , "Create folder" , Dropbox);
NewTest(TestTable, "DropboxAPI_CreateDeleteTag" , "Create/Delete tag" , Dropbox);
NewTest(TestTable, "DropboxAPI_GetAccount" , "Get account data" , Dropbox);
NewTest(TestTable, "DropboxAPI_AccessManagement" , "Access management" , Dropbox);
NewTest(TestTable, "DropboxAPI_GetFolderFileList" , "Get list of folder files" , Dropbox);
NewTest(TestTable, "B24_TokenManagment" , "Token management" , Bitrix);
NewTest(TestTable, "B24_ServerTime" , "Server time" , Bitrix);
NewTest(TestTable, "B24_PostsManagment" , "Posts managment" , Bitrix);
NewTest(TestTable, "B24_TaskManagment" , "Tasks managment" , Bitrix);
NewTest(TestTable, "B24_CommentsManagment" , "Comments managment" , Bitrix);
NewTest(TestTable, "B24_WorkingWithDrive" , "Working with drive" , Bitrix);
NewTest(TestTable, "B24_Kanban" , "Kanban" , Bitrix);
NewTest(TestTable, "B24_Timekeeping" , "Timekeeping" , Bitrix);
NewTest(TestTable, "B24_ChatManagment" , "Chats works" , Bitrix);
NewTest(TestTable, "B24_TokenManagment" , "Token management" , Bitrix);
NewTest(TestTable, "B24_ServerTime" , "Server time" , Bitrix);
NewTest(TestTable, "B24_PostsManagment" , "Posts managment" , Bitrix);
NewTest(TestTable, "B24_TaskManagment" , "Tasks managment" , Bitrix);
NewTest(TestTable, "B24_CommentsManagment" , "Comments managment" , Bitrix);
NewTest(TestTable, "B24_WorkingWithDrive" , "Working with drive" , Bitrix);
NewTest(TestTable, "B24_Kanban" , "Kanban" , Bitrix);
NewTest(TestTable, "B24_Timekeeping" , "Timekeeping" , Bitrix);
NewTest(TestTable, "B24_ChatManagment" , "Chats works" , Bitrix);
NewTest(TestTable, "B24_NotificationsManagment" , "Notifications managment" , Bitrix);
Return TestTable;
EndFunction
EndFunction
Function ExpectsThat(Value) Export
Try
Module = GetCommonModule("ЮТест");
Module = GetCommonModule("ЮТест");
Ожидаем = TypeOf(Module) = Type("CommonModule");
Return Module.ОжидаетЧто(Value);
Return Module.ОжидаетЧто(Value);
Except
Return Ожидаем.Что(Value);
EndTry;
EndFunction
Function FormYAXTests() Export
Module = GetCommonModule("ЮТТесты");
Sections = GetTestingSectionMapping();
Module = GetCommonModule("ЮТТесты");
Sections = GetTestingSectionMapping();
TestTable = GetTestTable();
For Each Section In Sections Do
CurrentSection = Section.Key;
Filter = New Structure("Section", CurrentSection);
SectionTests = TestTable.FindRows(Filter);
Filter = New Structure("Section", CurrentSection);
SectionTests = TestTable.FindRows(Filter);
Set = Module.ДобавитьТестовыйНабор(CurrentSection);
For Each Test In SectionTests Do
Set.ДобавитьСерверныйТест(Test.Method, Test.Synonym);
EndDo;
EndDo;
Return "";
EndFunction
Function FormAssertsTests() Export
TestTable = GetTestTable();
TestTable = GetTestTable();
ArrayOfTests = New Array;
For Each Test In TestTable Do
For Each Test In TestTable Do
ArrayOfTests.Add(Test.Method);
EndDo;
Return ArrayOfTests;
EndFunction
Function GetParameter(Parameter) Export
Function GetParameter(Parameter) Export
Path = DataFilePath();
Path = DataFilePath();
Return GetValueFromFile(Parameter, Path);
EndFunction
Function GetBinary(Parameter) Export
Path = DataFilePath();
Path = DataFilePath();
LocalParameter = Parameter + "Local";
MainValue = GetValueFromFile(Parameter , Path);
LocalValue = GetValueFromFile(LocalParameter, Path);
MainValue = GetValueFromFile(Parameter , Path);
LocalValue = GetValueFromFile(LocalParameter, Path);
LocalFile = New File(LocalValue);
If LocalFile.Exist() Then
Value = New BinaryData(LocalValue);
Else
Value = MainValue;
EndIf;
If TypeOf(Value) = Type("String") Then
Value = GetFilePath(Value, LocalParameter);
Value = GetFilePath(Value, LocalParameter);
EndIf;
Return Value;
EndFunction
Function GetFilePath(Val Path, LocalParameter, Val SaveLocally = True) Export
If StrFind(Path, "http") > 0
If StrFind(Path, "http") > 0
Or StrFind(Path, "www") > 0 Then
TFN = GetTempFileName();
TFN = GetTempFileName();
CopyFile(Path, TFN);
Path = TFN;
Path = TFN;
Binary = New BinaryData(Path);
If SaveLocally Then
WriteParameter(LocalParameter, TFN);
Else
DeleteFiles(TFN);
EndIf;
Else
Binary = New BinaryData(Path);
EndIf;
Return Binary;
EndFunction
Procedure ParameterToCollection(Parameter, Collection) Export
Value = GetParameter(Parameter);
Collection.Insert(Parameter, Value);
EndProcedure
Procedure BinaryToCollection(Parameter, Collection) Export
Value = GetBinary(Parameter);
Collection.Insert(Parameter, Value);
EndProcedure
Procedure WriteParameter(Parameter, Value) Export
Path = DataFilePath();
Path = DataFilePath();
WriteParameterToFile(Parameter, Value, Path);
EndProcedure
Procedure WriteLog(Val Result, Val Method, Val Library = "") Export
Header = String(OPI_Tools.GetCurrentDate()) + " | " + Method;
Try
Data = OPI_Tools.JSONString(Result);
Except
Data = "Not JSON: " + String(Result);
EndTry;
Data = " " + Data;
Data = " " + Data;
Message(Header);
Message(Chars.LF);
Message(Data);
Message(Chars.LF);
Message("---------------------------------");
Message(Chars.LF);
If ValueIsFilled(Library) Then
WriteLogFile(Data, Method, Library);
EndIf;
EndProcedure
#EndRegion
#Region Private
Function GetValueFromFile(Parameter, Path)
Values = OPI_Tools.ReadJSONFile(Path);
Function GetValueFromFile(Parameter, Path)
Values = OPI_Tools.ReadJSONFile(Path);
Return ?(Values.Property(Parameter), Values[Parameter], "");
EndFunction
Function DataFilePath()
Path = "";
Path = "";
PossiblePaths = New Array;
PossiblePaths.Add("./data.json");
PossiblePaths.Add("C:\GDrive\Мой Диск\data.json");
PossiblePaths.Add("D:\GD\Мой Диск\data.json");
For Each PossiblePath In PossiblePaths Do
RepositoryFile = New File(PossiblePath);
If RepositoryFile.Exist() Then
Path = PossiblePath;
EndIf;
EndIf;
EndDo;
Return Path;
EndFunction
Function GetCommonModule(Val Name)
Module = Eval(Name);
Return Module;
Module = Eval(Name);
Return Module;
EndFunction
Procedure NewTest(ValueTable, Val Method, Val Synonym, Val Section)
NewTest = ValueTable.Add();
NewTest.Method = Method;
NewTest = ValueTable.Add();
NewTest.Method = Method;
NewTest.Synonym = Synonym;
NewTest.Section = Section;
EndProcedure
Procedure WriteParameterToFile(Val Parameter, Val Value, Val Path)
Values = OPI_Tools.ReadJSONFile(Path);
Values.Insert(Parameter, Value);
Record = New JSONWriter;
Record = New JSONWriter;
JSONWriterSettings = New JSONWriterSettings(JSONLineBreak.Auto, Chars.Tab);
Record.OpenFile(Path, , , JSONWriterSettings);
WriteJSON(Record, Values);
@ -452,37 +452,37 @@ Procedure WriteParameterToFile(Val Parameter, Val Value, Val Path)
EndProcedure
Procedure WriteLogFile(Val Data, Val Method, Val Library)
Try
LogPath = "./docs/ru/results";
LogPath = "./docs/ru/results";
LibraryLogPath = LogPath + "/" + Library;
LogDirectory = New File(LogPath);
If Not LogDirectory.Exist() Then
CreateDirectory(LogPath);
EndIf;
LibraryLogCatalog = New File(LibraryLogPath);
If Not LibraryLogCatalog.Exist() Then
CreateDirectory(LibraryLogPath);
EndIf;
FilePath = LibraryLogPath + "/" + Method + ".log";
LogFile = New File(FilePath);
LogFile = New File(FilePath);
If Not LogFile.Exist() Then
LogDocument = New TextDocument;
LogDocument.SetText(Data);
LogDocument.Write(FilePath);
EndIf;
Except
Message("Failed to write log file!: " + ErrorDescription());
Message("Failed to write log file!: " + ErrorDescription());
EndTry;
EndProcedure
#EndRegion

242
src/en/OInt/tools/Modules/OPI_TypeConversion.os
View File

@ -39,268 +39,268 @@
#Region Internal
Procedure GetBinaryData(Value) Export
If Value = Undefined Then
Return;
EndIf;
Try
Try
If TypeOf(Value) = Type("BinaryData") Then
Return;
Else
File = New File(Value);
If File.Exist() Then
Value = New BinaryData(Value);
ElsIf StrFind(Value, "//") Then
Value = OPI_Tools.Get(Value);
Else
Value = Base64Value(Value);
EndIf;
EndIf;
Except
Raise "Error getting binary data from parameter: " + ErrorDescription();
EndTry;
EndProcedure
Procedure GetBinaryOrStream(Value) Export
If Value = Undefined Then
Return;
EndIf;
If TypeOf(Value) <> Type("String") Then
GetBinaryData(Value);
Return;
EndIf;
File = New File(Value);
If File.Exist() Then
Value = New FileStream(Value, FileOpenMode.Open);
Value = New FileStream(Value, FileOpenMode.Open);
Else
GetBinaryData(Value);
EndIf;
EndProcedure
Procedure GetCollection(Value) Export
If Value = Undefined Then
Return;
EndIf;
Try
Try
InitialValue = Value;
If ThisIsCollection(Value) Then
Return;
Else
If TypeOf(Value) = Type("BinaryData") Then
Value = GetStringFromBinaryData(Value);
Value = GetStringFromBinaryData(Value);
Else
Value = OPI_Tools.NumberToString(Value);
Value = OPI_Tools.NumberToString(Value);
EndIf;
File = New File(Value);
File = New File(Value);
JSONReader = New JSONReader;
If File.Exist() Then
JSONReader.OpenFile(Value);
ElsIf StrStartsWith(Lower(Value), "http") Then
TFN = GetTempFileName();
CopyFile(Value, TFN);
JSONReader.OpenFile(TFN);
JSONReader.Read();
DeleteFiles(TFN);
Else
JSONReader.SetString(TrimAll(Value));
EndIf;
Value = ReadJSON(JSONReader, True, Undefined, JSONDateFormat.ISO);
JSONReader.Close();
If (Not ThisIsCollection(Value)) Or Not ValueIsFilled(Value) Then
Value = InitialValue;
GetArray(Value);
EndIf;
EndIf;
Except
Value = InitialValue;
GetArray(Value);
GetArray(Value);
EndTry;
EndProcedure
Procedure GetArray(Value) Export
If TypeOf(Value) = Type("Array") Then
Return;
EndIf;
If TypeOf(Value) = Type("String")
If TypeOf(Value) = Type("String")
And StrStartsWith(Value, "[")
And StrEndsWith(Value, "]") Then
CommaInQuotes = "','";
Value = StrReplace(Value, "['" , "");
Value = StrReplace(Value, "']" , "");
Value = StrReplace(Value, "['" , "");
Value = StrReplace(Value, "']" , "");
Value = StrReplace(Value, "', '" , CommaInQuotes);
Value = StrReplace(Value, "' , '", CommaInQuotes);
Value = StrReplace(Value, "' ,'" , CommaInQuotes);
Value = StrSplit(Value, CommaInQuotes, False);
For N = 0 To Value.UBound() Do
For N = 0 To Value.UBound() Do
Value[N] = TrimAll(Value[N]);
EndDo;
Else
If TypeOf(Value) = Type("Number") Then
Value = OPI_Tools.NumberToString(Value);
Value = OPI_Tools.NumberToString(Value);
EndIf;
OPI_Tools.ValueToArray(Value);
EndIf;
EndProcedure
Procedure GetBoolean(Value) Export
If Value = Undefined Then
Return;
EndIf;
Try
Try
If TypeOf(Value) = Type("Boolean") Then
Return;
Else
Value = Boolean(Value);
Value = Boolean(Value);
EndIf;
Except
Raise "Error getting boolean data from parameter";
EndTry;
EndProcedure
Procedure GetLine(Value, Val FromSource = False) Export
If Value = Undefined Then
Return;
EndIf;
Try
Try
If ThisIsSymbolic(Value) Then
If Not FromSource Then
Value = OPI_Tools.NumberToString(Value);
Return;
Return;
EndIf;
Value = OPI_Tools.NumberToString(Value);
File = New File(Value);
Value = OPI_Tools.NumberToString(Value);
File = New File(Value);
If File.Exist() Then
TextReader = New TextReader(Value);
Value = TextReader.Read();
Value = TextReader.Read();
TextReader.Close();
ElsIf StrStartsWith(Lower(Value), "http") Then
TFN = GetTempFileName();
CopyFile(Value, TFN);
TextReader = New TextReader(TFN);
Value = TextReader.Read();
Value = TextReader.Read();
TextReader.Close();
DeleteFiles(TFN);
Else
Return;
EndIf;
ElsIf TypeOf(Value) = Type("BinaryData") Then
Value = GetStringFromBinaryData(Value);
ElsIf ThisIsCollection(Value) Then
Value = OPI_Tools.JSONString(Value);
Value = OPI_Tools.JSONString(Value);
Else
Return;
EndIf;
Except
Value = String(Value);
Return;
EndTry;
EndProcedure
Procedure GetDate(Value) Export
If Value = Undefined Then
Return;
EndIf;
Date = "Date";
Try
Try
If TypeOf(Value) = Type(Date) Then
Return;
Else
Value = XMLValue(Type(Date), Value);
Else
Value = XMLValue(Type(Date), Value);
EndIf;
Except
OOD = New TypeDescription(Date);
OOD = New TypeDescription(Date);
Value = OOD.AdjustValue(Value);
EndTry;
EndProcedure
Procedure GetNumber(Value) Export
TypeDescription = New TypeDescription("Number");
Value = TypeDescription.AdjustValue(Value);
Value = TypeDescription.AdjustValue(Value);
EndProcedure
#EndRegion
@ -308,19 +308,19 @@ EndProcedure
#Region Private
Function ThisIsCollection(Val Value)
Return TypeOf(Value) = Type("Array")
Return TypeOf(Value) = Type("Array")
Or TypeOf(Value) = Type("Structure")
Or TypeOf(Value) = Type("Map");
EndFunction
EndFunction
Function ThisIsSymbolic(Val Value)
Return TypeOf(Value) = Type("String")
Or TypeOf(Value) = Type("Number")
Return TypeOf(Value) = Type("String")
Or TypeOf(Value) = Type("Number")
Or TypeOf(Value) = Type("Date");
EndFunction
EndFunction
#EndRegion

46
src/en/OInt/tools/Modules/internal/Modules/OPI_Cryptography.os
View File

@ -39,75 +39,75 @@
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2019, LLC 1C-Soft
// All rights reserved. This program and accompanying materials are provided
// All rights reserved. This program and accompanying materials are provided
// under the terms of the Attribution 4.0 International (CC BY 4.0 license)
// License text available at:
// https://creativecommons.org/licenses/by/4.0/legalcode
///////////////////////////////////////////////////////////////////////////////////////////////////////
Function HMACSHA256(Val Key, Val Data) Export
Return HMAC(Key, Data, HashFunction.SHA256, 64);
EndFunction
Function Hash(BinaryData, Type) Export
Hashing = New DataHashing(Type);
Hashing.Append(BinaryData);
Return Hashing.HashSum;
EndFunction
Function HMAC(Val Key, Val Data, Type, BlockSize) Export
Twice = 2;
If Key.Size() > BlockSize Then
Key = Hash(Key, Type);
EndIf;
If Key.Size() <= BlockSize Then
Key = GetHexStringFromBinaryData(Key);
Key = Left(Key + RepeatString("00", BlockSize), BlockSize * Twice);
Key = GetHexStringFromBinaryData(Key);
Key = Left(Key + RepeatString("00", BlockSize), BlockSize * Twice);
EndIf;
Key = GetBinaryDataBufferFromBinaryData(GetBinaryDataFromHexString(Key));
Ipad = GetBinaryDataBufferFromHexString(RepeatString("36", BlockSize));
Opad = GetBinaryDataBufferFromHexString(RepeatString("5c", BlockSize));
Ipad.WriteBitwiseXor(0, Key);
Ikeypad = GetBinaryDataFromBinaryDataBuffer(ipad);
Opad.WriteBitwiseXor(0, Key);
Okeypad = GetBinaryDataFromBinaryDataBuffer(opad);
Return Hash(UniteBinaryData(okeypad, Hash(UniteBinaryData(ikeypad, Data), Type)), Type);
EndFunction
Function UniteBinaryData(BinaryData1, BinaryData2) Export
BinaryDataArray = New Array;
BinaryDataArray.Add(BinaryData1);
BinaryDataArray.Add(BinaryData2);
Return ConcatenateBinaryData(BinaryDataArray);
EndFunction
Function RepeatString(String, Count) Export
Parts = New Array(Count);
For K = 1 To Count Do
Parts.Add(String);
EndDo;
Return StrConcat(Parts, "");
EndFunction
#EndRegion

754
src/en/OInt/tools/Modules/internal/Modules/OPI_Tools.os
View File

File diff suppressed because it is too large Load Diff

426
src/en/OPI/src/CommonModules/OPI_Airtable/Module.bsl
View File

@ -42,91 +42,91 @@
// Get list of bases
// Gets the list of available bases
//
//
// Parameters:
// Token - String - Token - token
// Indent - String - Next page identifier of the base list from the previous request - offset
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
// Map Of KeyAndValue - serialized JSON response from Airtable
Function GetListOfBases(Val Token, Val Indent = "") Export
OPI_TypeConversion.GetLine(Indent);
URL = "https://api.airtable.com/v0/meta/bases";
Headers = GetAuthorizationHeader(Token);
URL = "https://api.airtable.com/v0/meta/bases";
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure;
OPI_Tools.AddField("offset", Indent, "String", Parameters);
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Get base tables
// Gets the schema of base tables
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Base identifier - base
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function GetDatabaseTables(Val Token, Val Base) Export
OPI_TypeConversion.GetLine(Base);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables";
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables";
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Create base
// Creates a new database
//
//
// Parameters:
// Token - String - Token - token
// Workspace - String - Workspace identifier - ws
// Name - String - New base name - title
// TableCollection - Map Of KeyAndValue - Table description: Key > name, Value > array of fields - tablesdata
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function CreateDatabase(Val Token, Val Workspace, Val Name, Val TableCollection) Export
OPI_TypeConversion.GetCollection(TableCollection);
If Not TypeOf(TableCollection) = Type("Structure")
If Not TypeOf(TableCollection) = Type("Structure")
And Not TypeOf(TableCollection) = Type("Map") Then
Raise "Error in table collection data";
EndIf;
URL = "https://api.airtable.com/v0/meta/bases";
Headers = GetAuthorizationHeader(Token);
URL = "https://api.airtable.com/v0/meta/bases";
Headers = GetAuthorizationHeader(Token);
TableArray = New Array;
For Each Table In TableCollection Do
Description = GenerateTableDescription(Table.Key, Table.Value);
TableArray.Add(Description);
EndDo;
Parameters = New Structure;
OPI_Tools.AddField("name" , Name , "String", Parameters);
OPI_Tools.AddField("tables" , TableArray , "Array", Parameters);
OPI_Tools.AddField("workspaceId", Workspace, "String", Parameters);
OPI_Tools.AddField("name" , Name , "String", Parameters);
OPI_Tools.AddField("tables" , TableArray , "Array" , Parameters);
OPI_Tools.AddField("workspaceId", Workspace , "String", Parameters);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
@ -137,56 +137,56 @@ EndFunction
// Create table
// Creates a new table in the base
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Base identifier - base
// Name - String - New table name - title
// FieldArray - Array of Structure - Array of field descriptions - fieldsdata
// Description - String - Table description - description
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function CreateTable(Val Token, Val Base, Val Name, Val FieldArray, Val Description = "") Export
OPI_TypeConversion.GetLine(Base);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables";
Headers = GetAuthorizationHeader(Token);
Parameters = GenerateTableDescription(Name, FieldArray, Description);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables";
Headers = GetAuthorizationHeader(Token);
Parameters = GenerateTableDescription(Name, FieldArray, Description);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Modify table
// Changes the name and/or description of the base
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Base identifier - base
// Table - String - Table identifier - table
// Name - String - New name - title
// Description - String - New description - description
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function ModifyTable(Val Token, Val Base, Val Table, Val Name = "", Val Description = "") Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables/" + Table;
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure;
OPI_Tools.AddField("name" , Name, "String", Parameters);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables/" + Table;
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure;
OPI_Tools.AddField("name" , Name , "String", Parameters);
OPI_Tools.AddField("description", Description , "String", Parameters);
Response = OPI_Tools.Patch(URL, Parameters, Headers);
Return Response;
EndFunction
@ -197,40 +197,40 @@ EndFunction
// Create field
// Creates a new field in the table
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Base identifier - base
// Table - String - Table identifier - table
// FieldStructure - Structure of KeyAndValue - Description of the new field - fielddata
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function CreateField(Val Token, Val Base, Val Table, Val FieldStructure) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetCollection(FieldStructure);
If Not TypeOf(FieldStructure) = Type("Structure")
If Not TypeOf(FieldStructure) = Type("Structure")
And Not TypeOf(FieldStructure) = Type("Map") Then
Raise "Error in field description data";
EndIf;
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables/" + Table + "/fields";
Headers = GetAuthorizationHeader(Token);
URL = "https://api.airtable.com/v0/meta/bases/" + Base + "/tables/" + Table + "/fields";
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Post(URL, FieldStructure, Headers);
Return Response;
EndFunction
// Modify field
// Changes the name and/or description of an existing table field
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Base identifier Base - base
@ -238,152 +238,152 @@ EndFunction
// Field - String - Field identifier - field
// Name - String - New name - title
// Description - String - New description - description
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function ModifyField(Val Token, Val Base, Val Table, Val Field, Val Name = "", Val Description = "") Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Field);
URL = "https://api.airtable.com/v0/meta/bases/"
+ Base
+ "/tables/"
+ Table
+ "/fields/"
URL = "https://api.airtable.com/v0/meta/bases/"
+ Base
+ "/tables/"
+ Table
+ "/fields/"
+ Field;
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure();
OPI_Tools.AddField("name" , Name, "String", Parameters);
OPI_Tools.AddField("name" , Name , "String", Parameters);
OPI_Tools.AddField("description", Description , "String", Parameters);
Response = OPI_Tools.Patch(URL, Parameters, Headers);
Return Response;
EndFunction
// Get field (string)
// Gets the description of a string field
//
//
// Parameters:
// Name - String - New field name - title
//
//
// Returns:
// Structure - Field description
Function GetStringField(Val Name) Export
Return PrimitiveFieldDescription(Name, "richText");
EndFunction
// Get field (numeric)
// Gets the description of a numeric field
//
//
// Parameters:
// Name - String - New field name - title
// Precision - Number, String - Number of decimal places - precision
//
//
// Returns:
// Structure - Field description
Function GetNumberField(Val Name, Val Precision = 0) Export
OPI_TypeConversion.GetNumber(Precision);
OptionsStructure = New Structure("precision", Precision);
Return PrimitiveFieldDescription(Name, "number", OptionsStructure);
EndFunction
// Get field (file)
// Gets the description of a file field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetAttachmentField(Val Name) Export
Return PrimitiveFieldDescription(Name, "multipleAttachments");
EndFunction
// Get field (checkbox)
// Gets the description of a boolean field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetCheckboxField(Val Name) Export
OptionsStructure = New Structure("icon,color", "check", "yellowBright");
Return PrimitiveFieldDescription(Name, "checkbox", OptionsStructure);
EndFunction
// Get field (date)
// Gets the description of a date field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetDateField(Val Name) Export
FormatStructure = New Structure("format,name", "YYYY-MM-DD", "iso");
FormatStructure = New Structure("format,name", "YYYY-MM-DD", "iso");
OptionsStructure = New Structure("dateFormat", FormatStructure);
Return PrimitiveFieldDescription(Name, "date", OptionsStructure);
EndFunction
// Get field (email)
// Gets the description of an email field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetEmailField(Val Name) Export
Return PrimitiveFieldDescription(Name, "email");
EndFunction
// Get field (phone)
// Gets the description of a phone number field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetPhoneField(Val Name) Export
Return PrimitiveFieldDescription(Name, "phoneNumber");
EndFunction
// Get field (url)
// Gets the description of a URL field
//
//
// Parameters:
// Name - String - Field name - title
//
//
// Returns:
// Structure - Field description
Function GetLinkField(Val Name) Export
Return PrimitiveFieldDescription(Name, "url");
EndFunction
#EndRegion
@ -392,67 +392,67 @@ EndFunction
// Get list of records
// Gets the list of records of the selected table
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Indent - String - Next page identifier of data from the previous request - offset
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function GetListOfRecords(Val Token, Val Base, Val Table, Val Indent = "") Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table;
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure();
OPI_Tools.AddField("offset", Indent, "String", Parameters);
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Get record
// Gets row data of the table by identifier
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Record - String - Record identifier in the table - record
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function GetRecord(Val Token, Val Base, Val Table, Val Record) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Record);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record;
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Create records
// Creates one or an array of records by description or an array of field value descriptions
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Data - Structure, Array of Structure - Set or array of sets of pairs Key : Value > Field : FieldValue - data
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function CreatePosts(Val Token, Val Base, Val Table, Val Data) Export
@ -460,52 +460,52 @@ Function CreatePosts(Val Token, Val Base, Val Table, Val Data) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetCollection(Data);
Parameters = New Structure();
AddDataDescription(Data, Parameters);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table;
Parameters = New Structure();
AddDataDescription(Data, Parameters);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table;
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
Return Response;
EndFunction
// Delete records
// Deletes one or an array of records by identifiers
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Records - String, Array of String - Identifier or array of record identifiers - records
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function DeletePosts(Val Token, Val Base, Val Table, Val Records) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetArray(Records);
RecordString = "";
For Each Record In Records Do
RecordString = RecordString
RecordString = RecordString
+ ?(ValueIsFilled(RecordString), "&", "?")
+ "records[]="
+ OPI_Tools.NumberToString(Record);
+ OPI_Tools.NumberToString(Record);
EndDo;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + RecordString;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + RecordString;
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
Return Response;
EndFunction
#EndRegion
@ -514,67 +514,67 @@ EndFunction
// Get comments
// Gets the list of comments for a record in the table
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Record - String - Record identifier in the table - record
// Indent - String - Next page identifier of data from the previous request - offset
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function GetComments(Val Token, Val Base, Val Table, Val Record, Val Indent = "") Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Record);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments";
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments";
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure();
OPI_Tools.AddField("offset", Indent, "String", Parameters);
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Create comment
// Creates a comment for a record in the table
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Record - String - Record identifier in the table - record
// Text - String - Comment text - text
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function CreateComment(Val Token, Val Base, Val Table, Val Record, Val Text) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Record);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments";
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments";
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure();
OPI_Tools.AddField("text", Text, "String", Parameters);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Modify comment
// Changes the text of an existing comment
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
@ -582,54 +582,54 @@ EndFunction
// Record - String - Record identifier in the table - record
// Comment - String - Comment identifier - comment
// Text - String - New comment text - text
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
Function EditComment(Val Token, Val Base, Val Table, Val Record, Val Comment, Val Text) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Record);
OPI_TypeConversion.GetLine(Comment);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments/" + Comment;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments/" + Comment;
Headers = GetAuthorizationHeader(Token);
Parameters = New Structure();
OPI_Tools.AddField("text", Text, "String", Parameters);
Response = OPI_Tools.Patch(URL, Parameters, Headers);
Return Response;
EndFunction
// Delete comment
// Deletes a comment for a table record
//
//
// Parameters:
// Token - String - Token - token
// Base - String - Database identifier - base
// Table - String - Table identifier - table
// Record - String - Record identifier in the table - record
// Comment - String - Comment identifier - comment
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Airtable
// Map Of KeyAndValue - serialized JSON response from Airtable
Function DeleteComment(Val Token, Val Base, Val Table, Val Record, Val Comment) Export
OPI_TypeConversion.GetLine(Base);
OPI_TypeConversion.GetLine(Table);
OPI_TypeConversion.GetLine(Record);
OPI_TypeConversion.GetLine(Comment);
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments/" + Comment;
URL = "https://api.airtable.com/v0/" + Base + "/" + Table + "/" + Record + "/comments/" + Comment;
Headers = GetAuthorizationHeader(Token);
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
#EndRegion
@ -639,58 +639,58 @@ EndFunction
#Region Private
Function GetAuthorizationHeader(Val Token)
OPI_TypeConversion.GetLine(Token);
Headers = New Map;
Headers.Insert("Authorization", "Bearer " + Token);
Return Headers;
EndFunction
Function GenerateTableDescription(Val Name, Val FieldArray, Val Description = "")
OPI_TypeConversion.GetLine(Name);
OPI_TypeConversion.GetCollection(FieldArray);
TableDescription = New Structure("name,fields", Name, FieldArray);
OPI_Tools.AddField("description", Description, "String", TableDescription);
Return TableDescription;
EndFunction
Function PrimitiveFieldDescription(Val Name, Val Type, Val Options = "")
FieldStructure = New Structure();
OPI_Tools.AddField("name" , Name, "String" , FieldStructure);
OPI_Tools.AddField("type" , Type , "String" , FieldStructure);
OPI_Tools.AddField("name" , Name , "String" , FieldStructure);
OPI_Tools.AddField("type" , Type , "String" , FieldStructure);
OPI_Tools.AddField("options", Options , "Collection", FieldStructure);
Return FieldStructure;
EndFunction
Procedure AddDataDescription(Val Data, Parameters)
If TypeOf(Data) = Type("Array") Then
SendArray = New Array;
For Each RecordDescription In Data Do
SendArray.Add(New Structure("fields", RecordDescription));
SendArray.Add(New Structure("fields", RecordDescription));
EndDo;
OPI_Tools.AddField("records", SendArray, "Array", Parameters);
Else
OPI_Tools.AddField("fields", Data, "Collection", Parameters);
OPI_Tools.AddField("fields", Data, "Collection", Parameters);
EndIf;
EndProcedure
#EndRegion

2312
src/en/OPI/src/CommonModules/OPI_Bitrix24/Module.bsl
View File

File diff suppressed because it is too large Load Diff

46
src/en/OPI/src/CommonModules/OPI_Cryptography/Module.bsl
View File

@ -39,75 +39,75 @@
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2019, LLC 1C-Soft
// All rights reserved. This program and accompanying materials are provided
// All rights reserved. This program and accompanying materials are provided
// under the terms of the Attribution 4.0 International (CC BY 4.0 license)
// License text available at:
// https://creativecommons.org/licenses/by/4.0/legalcode
///////////////////////////////////////////////////////////////////////////////////////////////////////
Function HMACSHA256(Val Key, Val Data) Export
Return HMAC(Key, Data, HashFunction.SHA256, 64);
EndFunction
Function Hash(BinaryData, Type) Export
Hashing = New DataHashing(Type);
Hashing.Append(BinaryData);
Return Hashing.HashSum;
EndFunction
Function HMAC(Val Key, Val Data, Type, BlockSize) Export
Twice = 2;
If Key.Size() > BlockSize Then
Key = Hash(Key, Type);
EndIf;
If Key.Size() <= BlockSize Then
Key = GetHexStringFromBinaryData(Key);
Key = Left(Key + RepeatString("00", BlockSize), BlockSize * Twice);
Key = GetHexStringFromBinaryData(Key);
Key = Left(Key + RepeatString("00", BlockSize), BlockSize * Twice);
EndIf;
Key = GetBinaryDataBufferFromBinaryData(GetBinaryDataFromHexString(Key));
Ipad = GetBinaryDataBufferFromHexString(RepeatString("36", BlockSize));
Opad = GetBinaryDataBufferFromHexString(RepeatString("5c", BlockSize));
Ipad.WriteBitwiseXor(0, Key);
Ikeypad = GetBinaryDataFromBinaryDataBuffer(ipad);
Opad.WriteBitwiseXor(0, Key);
Okeypad = GetBinaryDataFromBinaryDataBuffer(opad);
Return Hash(UniteBinaryData(okeypad, Hash(UniteBinaryData(ikeypad, Data), Type)), Type);
EndFunction
Function UniteBinaryData(BinaryData1, BinaryData2) Export
BinaryDataArray = New Array;
BinaryDataArray.Add(BinaryData1);
BinaryDataArray.Add(BinaryData2);
Return ConcatBinaryData(BinaryDataArray);
EndFunction
Function RepeatString(String, Count) Export
Parts = New Array(Count);
For K = 1 To Count Do
Parts.Add(String);
EndDo;
Return StrConcat(Parts, "");
EndFunction
#EndRegion

666
src/en/OPI/src/CommonModules/OPI_Dropbox/Module.bsl
View File

File diff suppressed because it is too large Load Diff

420
src/en/OPI/src/CommonModules/OPI_GoogleCalendar/Module.bsl
View File

@ -43,131 +43,131 @@
// Create calendar
// Creates an empty calendar
//
//
// Parameters:
// Token - String - Token - token
// Name - String - Name of the created calendar - title
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CreateCalendar(Val Token, Val Name) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Name);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars";
URL = "https://www.googleapis.com/calendar/v3/calendars";
Parameters = New Structure;
Parameters.Insert("summary" , Name);
Parameters.Insert("timeZone", "Europe/Moscow");
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Get calendar
// Gets calendar information by ID
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetCalendarMetadata(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Edit calendar
// Edits properties of an existing calendar
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// Name - String - New name - title
// Description - String - New calendar description - description
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function EditCalendarMetadata(Val Token
, Val Calendar
, Val Name = ""
, Val Description = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
OPI_TypeConversion.GetLine(Name);
OPI_TypeConversion.GetLine(Description);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
Parameters = New Structure;
If ValueIsFilled(Name) Then
Parameters.Insert("summary", Name);
EndIf;
If ValueIsFilled(Description) Then
Parameters.Insert("description", Description);
EndIf;
Response = OPI_Tools.Patch(URL, Parameters, Headers, True);
Return Response;
EndFunction
// Clear primary calendar
// Clears the event list of the primary calendar
//
//
// Parameters:
// Token - String - Token - token
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function ClearMainCalendar(Val Token) Export
OPI_TypeConversion.GetLine(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/primary/clear";
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/primary/clear";
Response = OPI_Tools.Post(URL, , Headers, False);
Return Response;
EndFunction
// Delete calendar
// Deletes a calendar by ID
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteCalendar(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Calendar;
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
@ -178,105 +178,105 @@ EndFunction
// Get list of calendars
// Gets an array of account calendars
//
//
// Parameters:
// Token - String - Token - token
//
//
// Returns:
// Map Of KeyAndValue - Array of calendar data mappings
Function GetCalendarList(Val Token) Export
OPI_TypeConversion.GetLine(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
ArrayOfCalendars = New Array;
GetCalendarsListRecursively(Headers, ArrayOfCalendars);
Return ArrayOfCalendars;
EndFunction
// Add calendar to list
// Adds an existing calendar to the user's list
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function AddCalendarToList(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList";
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList";
Parameters = New Structure;
Parameters.Insert("id", Calendar);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Get list calendar
// Gets a calendar from the user's list by ID
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetListCalendar(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar;
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Remove calendar from list
// Removes a calendar from the user's list
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteCalendarFromList(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar;
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
// Edit list calendar
// Edits the properties of a calendar from the user's list
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// PrimaryColor - String - HEX primary color (#ffffff) - primary
// SecondaryColor - String - HEX secondary color (#ffffff) - secondary
// Hidden - Boolean - Hidden calendar - hidden
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function EditListCalendar(Val Token
@ -284,23 +284,23 @@ Function EditListCalendar(Val Token
, Val PrimaryColor
, Val SecondaryColor
, Val Hidden = False) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
OPI_TypeConversion.GetLine(PrimaryColor);
OPI_TypeConversion.GetLine(SecondaryColor);
OPI_TypeConversion.GetBoolean(Hidden);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar + "?colorRgbFormat=true";
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Calendar + "?colorRgbFormat =true";
Parameters = New Map;
Parameters.Insert("hidden" , Hidden);
Parameters.Insert("hidden" , Hidden);
Parameters.Insert("foregroundColor", PrimaryColor);
Parameters.Insert("backgroundColor", SecondaryColor);
Response = OPI_Tools.Put(URL, Parameters, Headers);
Return Response;
EndFunction
@ -310,167 +310,167 @@ EndFunction
#Region EventManagement
// Get event description !NOCLI
//
//
// Returns:
// Map Of KeyAndValue - Empty event template
Function GetEventDescription() Export
CurrentDate = OPI_Tools.GetCurrentDate();
Hour = 3600;
Event = New Map;
Event.Insert("Description" , ""); // Event description
Event.Insert("Title" , "New event"); // Title events
Event.Insert("Venue" , ""); // String description of the venue of the event
Event.Insert("StartDate" , CurrentDate); // Date of start events
Event.Insert("EndDate" , CurrentDate + Hour); // Date of end events
Hour = 3600;
Event = New Map;
Event.Insert("Description" , ""); // Event description
Event.Insert("Title" , "New event"); // Title events
Event.Insert("Venue" , ""); // String description of the venue of the event
Event.Insert("StartDate" , CurrentDate); // Date of start events
Event.Insert("EndDate" , CurrentDate + Hour); // Date of end events
Event.Insert("ArrayOfAttachmentURLs", New Map); // Key - name, Value - URL to file
Event.Insert("SendNotifications" , True); // Indication of sending notifications to participants
Event.Insert("SendNotifications" , True); // Indication of sending notifications to participants
Return Event;
EndFunction
// Get list of events
// Gets the list of all calendar events
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
//
//
// Returns:
// Map Of KeyAndValue - Array of event maps
Function GetEventList(Val Token, Val Calendar) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
ArrayOfEvents = New Array;
GetEventsListRecursively(Headers, Calendar, ArrayOfEvents);
Return ArrayOfEvents;
EndFunction
// Get event
// Gets an event by ID
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// Event - String - Event ID - event
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetEvent(Val Token, Val Calendar, Val Event) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
OPI_TypeConversion.GetLine(Event);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
+ "/events/"
+ Event;
+ Event;
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Create event
// Creates a new event
//
//
// Parameters:
// Token - String - Token - token
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// EventDescription - Map Of KeyAndValue - Event description - props
//
//
// Returns:
// String, Arbitrary, HTTPResponse, BinaryData, Undefined - Google server response
Function CreateEvent(Val Token, Val Calendar, Val EventDescription) Export
Function CreateEvent(Val Token, Val Calendar, Val EventDescription) Export
Return EventManagement(Token, Calendar, EventDescription);
EndFunction
// Move event
// Moves an event to another calendar
//
//
// Parameters:
// Token - String - Token - token
// SourceCalendar - String - ID of the source calendar - from
// TargetCalendar - String - ID of the target calendar - to
// Event - String - ID of the source calendar event - event
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function MoveEvent(Val Token, Val SourceCalendar, Val TargetCalendar, Val Event) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(SourceCalendar);
OPI_TypeConversion.GetLine(TargetCalendar);
OPI_TypeConversion.GetLine(Event);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ SourceCalendar
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ SourceCalendar
+ "/events/"
+ Event
+ "/move?destination="
+ TargetCalendar;
+ TargetCalendar;
Response = OPI_Tools.Post(URL, , Headers);
Return Response;
EndFunction
// Edit event
// Edits an existing event
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// EventDescription - String - New event description - props
// Event - String - Event ID - event
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function EditEvent(Val Token, Val Calendar, Val EventDescription, Val Event) Export
Return EventManagement(Token, Calendar, EventDescription, Event);
EndFunction
// Delete event
// Deletes an event by ID
//
//
// Parameters:
// Token - String - Token - token
// Calendar - String - Calendar ID - calendar
// Event - String - Event ID - event
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteEvent(Val Token, Val Calendar, Val Event) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
OPI_TypeConversion.GetLine(Event);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
+ "/events/"
+ Event;
+ Event;
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
@ -482,51 +482,51 @@ EndFunction
#Region Private
Function ConvertDate(Val Date)
OPI_TypeConversion.GetDate(Date);
DateStructure = New Structure;
If Not TypeOf(Date) = Type("Date") Then
Return Undefined;
EndIf;
If Date = BegOfDay(Date) Then
If Date = BegOfDay(Date) Then
DateFormat = "DF=yyyy-MM-dd";
Field = "date";
Field = "date";
Else
DateFormat = "DF=yyyy-MM-ddTHH:mm:ssZ";
Field = "dateTime";
Field = "dateTime";
EndIf;
Date = Format(Date, DateFormat);
DateStructure.Insert(Field , Date);
DateStructure.Insert(Field , Date);
DateStructure.Insert("timeZone", "Europe/Moscow");
Return DateStructure;
EndFunction
Function ConvertAttachments(Val Attachments)
OPI_TypeConversion.GetCollection(Attachments);
AttachmentsArray = New Array;
If TypeOf(Attachments) = Type("Map") Or TypeOf(Attachments) = Type("Structure") Then
For Each Attachment In Attachments Do
CurrentAttachment = New Structure;
CurrentAttachment.Insert("title" , Attachment.Key);
CurrentAttachment.Insert("title" , Attachment.Key);
CurrentAttachment.Insert("fileUrl", Attachment.Value);
AttachmentsArray.Add(CurrentAttachment);
EndDo;
EndIf;
If AttachmentsArray.Count() > 0 Then
Return AttachmentsArray;
Else
@ -536,105 +536,105 @@ Function ConvertAttachments(Val Attachments)
EndFunction
Function EventManagement(Val Token, Val Calendar, Val EventDescription, Val Event = "")
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Calendar);
OPI_TypeConversion.GetLine(Event);
OPI_TypeConversion.GetCollection(EventDescription);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Existing = ValueIsFilled(Event);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Calendar
+ "/events"
+ ?(Existing, "/" + Event, "");
Date0 = EventDescription["StartDate"];
Date1 = EventDescription["EndDate"];
Attachments = EventDescription["ArrayOfAttachmentURLs"];
Attachments = ConvertAttachments(Attachments);
+ ?(Existing, "/" + Event, "");
Date0 = EventDescription["StartDate"];
Date1 = EventDescription["EndDate"];
Attachments = EventDescription["ArrayOfAttachmentURLs"];
Attachments = ConvertAttachments(Attachments);
Notifications = ?(EventDescription["SendNotifications"] = Undefined
, False
, EventDescription["SendNotifications"]);
Parameters = New Structure;
Parameters.Insert("summary" , EventDescription["Title"]);
Parameters.Insert("summary" , EventDescription["Title"]);
Parameters.Insert("description", EventDescription["Description"]);
Parameters.Insert("location" , EventDescription["Venue"]);
Parameters.Insert("start" , ConvertDate(Date0));
Parameters.Insert("end" , ConvertDate(Date1));
Parameters.Insert("attachments", Attachments);
URLParameters = New Structure;
URLParameters.Insert("sendUpdates" , ?(Notifications, "all", "none"));
Parameters.Insert("location" , EventDescription["Venue"]);
Parameters.Insert("start" , ConvertDate(Date0));
Parameters.Insert("end" , ConvertDate(Date1));
Parameters.Insert("attachments", Attachments);
URLParameters = New Structure;
URLParameters.Insert("sendUpdates" , ?(Notifications , "all" , "none"));
URLParameters.Insert("supportsAttachments" , ?(ValueIsFilled(Attachments), "true", "false"));
URL = URL + OPI_Tools.RequestParametersToString(URLParameters);
OPI_Tools.RemoveEmptyCollectionFields(Parameters);
If Existing Then
Response = OPI_Tools.Patch(URL, Parameters, Headers, True);
Else
Response = OPI_Tools.Post(URL, Parameters, Headers, True);
EndIf;
Return Response;
EndFunction
Procedure GetCalendarsListRecursively(Val Headers, ArrayOfCalendars, Page = "")
Items = "items";
NPT = "nextPageToken";
Procedure GetCalendarsListRecursively(Val Headers, ArrayOfCalendars, Page = "")
Items = "items";
NPT = "nextPageToken";
Parameters = New Structure;
If ValueIsFilled(Page) Then
Parameters.Insert("pageToken", Page);
EndIf;
Result = OPI_Tools.Get("https://www.googleapis.com/calendar/v3/users/me/calendarList"
, Parameters
, Headers);
Calendars = Result[Items];
Page = Result[NPT];
Page = Result[NPT];
For Each Calendar In Calendars Do
ArrayOfCalendars.Add(Calendar);
EndDo;
ArrayOfCalendars.Add(Calendar);
EndDo;
If Calendars.Count() > 0 And ValueIsFilled(Page) Then
GetCalendarsListRecursively(Headers, ArrayOfCalendars, Page);
GetCalendarsListRecursively(Headers, ArrayOfCalendars, Page);
EndIf;
EndProcedure
Procedure GetEventsListRecursively(Val Headers, Val Calendar, ArrayOfEvents, Page = "")
Items = "items";
NPT = "nextPageToken";
Procedure GetEventsListRecursively(Val Headers, Val Calendar, ArrayOfEvents, Page = "")
Items = "items";
NPT = "nextPageToken";
Parameters = New Structure;
If ValueIsFilled(Page) Then
Parameters.Insert("pageToken", Page);
EndIf;
Result = OPI_Tools.Get("https://www.googleapis.com/calendar/v3/calendars/" + Calendar + "/events"
, Parameters
, Headers);
Events = Result[Items];
Page = Result[NPT];
Page = Result[NPT];
For Each Event In Events Do
ArrayOfEvents.Add(Event);
EndDo;
ArrayOfEvents.Add(Event);
EndDo;
If Events.Count() > 0 And ValueIsFilled(Page) Then
GetEventsListRecursively(Headers, ArrayOfEvents, Page);
GetEventsListRecursively(Headers, ArrayOfEvents, Page);
EndIf;
EndProcedure
#EndRegion

500
src/en/OPI/src/CommonModules/OPI_GoogleDrive/Module.bsl
View File

@ -43,277 +43,277 @@
// Get object information
// Gets information about a folder or file by ID
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Identifier of the file or folder - object
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetObjectInformation(Val Token, Val Identifier) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
Parameters = New Structure;
Parameters.Insert("fields", "*");
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Get list of directories
// Gets the list of drive directories
//
//
// Parameters:
// Token - String - Token - token
// NameContains - String - Filter by name - querry
// Detailed - Boolean - Adds a list of files to the directory fields - depth
//
//
// Returns:
// Map Of KeyAndValue - Array of directory mappings
Function GetDirectoriesList(Val Token, Val NameContains = "", Val Detailed = False) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(NameContains);
OPI_TypeConversion.GetBoolean(Detailed);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
ArrayOfObjects = New Array;
Filter = New Array;
Filter = New Array;
Filter.Add("mimeType = 'application/vnd.google-apps.folder'");
If ValueIsFilled(NameContains) Then
Filter.Add("name contains '" + NameContains + "'");
EndIf;
GetObjectsListRecursively(Headers, ArrayOfObjects, Detailed, Filter);
If Detailed Then
BreakDownObjectsInDetail(Token, ArrayOfObjects);
BreakDownObjectsInDetail(Token, ArrayOfObjects);
EndIf;
Return ArrayOfObjects;
EndFunction
// Get list of files
// Gets the list of files
//
//
// Parameters:
// Token - String - Token - token
// NameContains - String - Filter by name - querry
// Directory - String - Filter by parent directory ID - catalog
//
//
// Returns:
// Map Of KeyAndValue - Array of file mappings
Function GetFilesList(Val Token, Val NameContains = "", Val Directory = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(NameContains);
OPI_TypeConversion.GetLine(Directory);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
ArrayOfObjects = New Array;
Filter = New Array;
Filter = New Array;
Filter.Add("mimeType != 'application/vnd.google-apps.folder'");
If ValueIsFilled(NameContains) Then
Filter.Add("name contains '" + NameContains + "'");
EndIf;
If ValueIsFilled(Directory) Then
Filter.Add("'" + Directory + "' in parents");
EndIf;
GetObjectsListRecursively(Headers, ArrayOfObjects, , Filter);
Return ArrayOfObjects;
EndFunction
// Upload file
// Uploads a file to the drive
//
//
// Parameters:
// Token - String - Token - token
// File - BinaryData,String - File to be uploaded - file
// Description - Map Of KeyAndValue - See GetFileDescription - props - JSON description or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function UploadFile(Val Token, Val File, Val Description) Export
Return FileManagement(Token, File, Description);
Return FileManagement(Token, File, Description);
EndFunction
// Create folder
// Creates an empty directory on the drive
//
//
// Parameters:
// Token - String - Token - token
// Name - String - Folder name - title
// Parent - String - Parent - catalog
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CreateFolder(Val Token, Val Name, Val Parent = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Name);
OPI_TypeConversion.GetLine(Parent);
Description = New Map;
Description.Insert("MIME" , "application/vnd.google-apps.folder");
Description.Insert("Name" , Name);
Description.Insert("MIME" , "application/vnd.google-apps.folder");
Description.Insert("Name" , Name);
Description.Insert("Description", "");
Description.Insert("Parent", ?(ValueIsFilled(Parent), Parent, "root"));
Description.Insert("Parent" , ?(ValueIsFilled(Parent), Parent, "root"));
Return FileManagement(Token, , Description);
EndFunction
// Download file
// Gets file by ID
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - File identifier - object
// SavePath - String - File save path - out
//
// SavePath - String - File save path - out
//
// Returns:
// BinaryData,String - Binary data or file path when SavePath parameter is specified
Function DownloadFile(Val Token, Val Identifier, Val SavePath = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
Parameters = New Map;
Parameters.Insert("alt", "media");
Response = OPI_Tools.Get(URL, Parameters , Headers, SavePath);
Return Response;
EndFunction
// Copy object
// Copies file or directory
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Object identifier - object
// NewName - String - New object name - title
// NewParent - String - New parent directory - catalog
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CopyObject(Val Token, Val Identifier, Val NewName = "", Val NewParent = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(NewName);
OPI_TypeConversion.GetLine(Identifier);
OPI_TypeConversion.GetLine(NewParent);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier + "/copy";
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier + "/copy";
Parameters = New Structure;
If ValueIsFilled(NewName) Then
Parameters.Insert("name", NewName);
EndIf;
If ValueIsFilled(NewParent) Then
ArrayOfParents = New Array;
ArrayOfParents.Add(NewParent);
Parameters.Insert("parents", ArrayOfParents);
EndIf;
Response = OPI_Tools.Post(URL, Parameters , Headers, True);
Return Response;
EndFunction
// Update file
// Updates file binary data
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Identifier of the object to update - object
// File - BinaryData,String - File source for update - file
// NewName - String - New file name (if necessary) - title
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function UpdateFile(Val Token, Val Identifier, Val File, Val NewName = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
OPI_TypeConversion.GetLine(NewName);
OPI_TypeConversion.GetBinaryData(File);
If ValueIsFilled(NewName) Then
Description = New Map;
Description.Insert("Name", NewName);
Else
Description = "";
EndIf;
Return FileManagement(Token, File, Description, Identifier);
EndFunction
// Delete object
// Deletes file or directory by ID
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Identifier of the object to delete - object
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteObject(Val Token, Val Identifier) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier;
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
// Get file description !NOCLI
//
//
// Returns:
// Map Of KeyAndValue - File description
Function GetFileDescription() Export
Description = New Map;
Description.Insert("MIME" , "image/jpeg"); // MIME-type uploading file
Description.Insert("Name" , "New file.jpg"); // File name with extension
Description.Insert("MIME" , "image/jpeg"); // MIME-type uploading file
Description.Insert("Name" , "New file.jpg"); // File name with extension
Description.Insert("Description" , "This is a new file"); // File description
Description.Insert("Parent" , "root"); // ID directory upload or "root" for upload in root
Description.Insert("Parent" , "root"); // ID directory upload or "root" for upload in root
Return Description;
EndFunction
#EndRegion
@ -322,107 +322,107 @@ EndFunction
// Create comment
// Creates a comment for a file or directory
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Identifier of the object that needs a comment - object
// Identifier - String - Identifier of the object that needs a comment - object
// Comment - String - Comment text - text
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CreateComment(Val Token, Val Identifier, Val Comment) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
OPI_TypeConversion.GetLine(Comment);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier + "/comments?fields=*";
URL = "https://www.googleapis.com/drive/v3/files/" + Identifier + "/comments?fields =*";
Parameters = New Structure;
Parameters.Insert("content", Comment);
Response = OPI_Tools.POST(URL, Parameters, Headers);
Return Response;
EndFunction
// Get comment
// Gets comment by ID
//
//
// Parameters:
// Token - String - Token - token
// ObjectID - String - Identifier of the file or directory where the comment is located - object
// CommentID - String - Comment identifier - comment
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetComment(Val Token, Val ObjectID, Val CommentID) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(ObjectID);
OPI_TypeConversion.GetLine(CommentID);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments/" + CommentID;
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments/" + CommentID;
Parameters = New Structure;
Parameters.Insert("fields", "*");
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Get list of comments
// Gets the list of all comments of the object
//
//
// Parameters:
// Token - String - Token - token
// ObjectID - String - Object identifier - object
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetCommentList(Val Token, Val ObjectID) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(ObjectID);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments";
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments";
Parameters = New Structure;
Parameters.Insert("fields", "*");
Response = OPI_Tools.Get(URL, Parameters, Headers);
Return Response;
EndFunction
// Delete comment
// Deletes comment by ID
//
//
// Parameters:
// Token - String - Token - token
// ObjectID - String - Identifier of the file or directory where the comment is located - object
// CommentID - String - Comment identifier - comment
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteComment(Val Token, Val ObjectID, Val CommentID) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(ObjectID);
OPI_TypeConversion.GetLine(CommentID);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments/" + CommentID;
URL = "https://www.googleapis.com/drive/v3/files/" + ObjectID + "/comments/" + CommentID;
Response = OPI_Tools.Delete(URL, , Headers);
Return Response;
EndFunction
@ -433,294 +433,294 @@ EndFunction
#Region Private
Procedure GetObjectsListRecursively(Val Headers, ArrayOfObjects, Detailed = False, Filter = "", Page = "")
URL = "https://www.googleapis.com/drive/v3/files";
Files = "files";
NPT = "nextPageToken";
Procedure GetObjectsListRecursively(Val Headers, ArrayOfObjects, Detailed = False, Filter = "", Page = "")
URL = "https://www.googleapis.com/drive/v3/files";
Files = "files";
NPT = "nextPageToken";
Parameters = New Structure;
Parameters.Insert("fields", "*");
If ValueIsFilled(Page) Then
Parameters.Insert("pageToken", Page);
EndIf;
If ValueIsFilled(Filter) And TypeOf(Filter) = Type("Array") Then
If ValueIsFilled(Filter) And TypeOf(Filter) = Type("Array") Then
FilterString = StrConcat(Filter, " and ");
Parameters.Insert("q", FilterString);
Parameters.Insert("q", FilterString);
EndIf;
Result = OPI_Tools.Get(URL, Parameters, Headers);
Objects = Result[Files];
Page = Result[NPT];
Page = Result[NPT];
For Each CurrentObject In Objects Do
ArrayOfObjects.Add(CurrentObject);
EndDo;
EndDo;
If Objects.Count() > 0 And ValueIsFilled(Page) Then
GetObjectsListRecursively(Headers, ArrayOfObjects, Detailed, Filter, Page);
GetObjectsListRecursively(Headers, ArrayOfObjects, Detailed, Filter, Page);
EndIf;
EndProcedure
Procedure BreakDownObjectsInDetail(Val Token, ArrayOfObjects)
Procedure BreakDownObjectsInDetail(Val Token, ArrayOfObjects)
For Each CurrentObject In ArrayOfObjects Do
ArrayOfFiles = New Array;
CurrentID = CurrentObject["id"];
CurrentID = CurrentObject["id"];
Result = GetFilesList(Token, , CurrentID);
For Each File In Result Do
ArrayOfFiles.Add(File);
ArrayOfFiles.Add(File);
EndDo;
CurrentObject.Insert("files", ArrayOfFiles);
EndDo;
EndProcedure
Procedure FormFileUploadParameters(Description)
FormedDescription = New Map;
OPI_Tools.RemoveEmptyCollectionFields(Description);
FieldMapping = New Map;
FieldMapping.Insert("MIME" , "mimeType");
FieldMapping.Insert("Name" , "name");
FieldMapping.Insert("MIME" , "mimeType");
FieldMapping.Insert("Name" , "name");
FieldMapping.Insert("Description" , "description");
FieldMapping.Insert("Parent" , "parents");
FieldMapping.Insert("Extension", "fileExtension");
FieldMapping.Insert("Parent" , "parents");
FieldMapping.Insert("Extension" , "fileExtension");
For Each Element In Description Do
If Element.Key = "Parent" Then
CurrentValue = New Array;
CurrentValue.Add(Element.Value);
Else
CurrentValue = Element.Value;
EndIf;
FieldName = FieldMapping.Get(Element.Key);
FormedDescription.Insert(FieldName, CurrentValue);
EndDo;
Description = FormedDescription;
EndProcedure
Function FileManagement(Val Token, Val File = "", Val Description = "", Val Identifier = "")
Function FileManagement(Val Token, Val File = "", Val Description = "", Val Identifier = "")
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Identifier);
If ValueIsFilled(Description) Then
OPI_TypeConversion.GetCollection(Description);
EndIf;
MimeType = "mimeType";
If ValueIsFilled(Identifier) Then
MIME = GetObjectInformation(Token, Identifier)[MimeType];
Else
MIME = Description["MIME"];
EndIf;
EndIf;
If Not ValueIsFilled(Description) Then
Description = New Map;
EndIf;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
FormFileUploadParameters(Description);
JSONDescription = OPI_Tools.JSONString(Description);
FileMapping = New Map;
If ValueIsFilled(File) Then
ChunkSize = 268435457;
Size = OPI_Tools.ConvertDataWithSizeRetrieval(File, ChunkSize);
ChunkSize = 268435457;
Size = OPI_Tools.ConvertDataWithSizeRetrieval(File, ChunkSize);
FileMapping.Insert(File, MIME);
If Size < ChunkSize And TypeOf(File) = Type("BinaryData") Then
Response = UploadSmallFile(JSONDescription, FileMapping, Headers, Identifier);
Else
Response = UploadLargeFile(Description, FileMapping, Headers, Identifier);
EndIf;
Else
Response = UploadSmallFile(JSONDescription, FileMapping, Headers, Identifier);
Response = UploadSmallFile(JSONDescription, FileMapping, Headers, Identifier);
EndIf;
Return Response;
EndFunction
Function UploadSmallFile(Val Description, Val FileMapping, Val Headers, Val Identifier = "")
URL = "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart";
If ValueIsFilled(Identifier) Then
URL = StrReplace(URL, "/files", "/files/" + Identifier);
URL = StrReplace(URL, "/files", "/files/" + Identifier);
Response = OPI_Tools.PatchMultipartRelated(URL, Description, FileMapping, Headers);
Else
Response = OPI_Tools.PostMultipartRelated(URL, Description, FileMapping, Headers);
EndIf;
Return Response;
EndFunction
Function UploadLargeFile(Val Description, Val FileMapping, Val Headers, Val Identifier = "")
For Each File In FileMapping Do
Binary = File.Key;
Break;
EndDo;
URL = "https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable";
If ValueIsFilled(Identifier) Then
URL = StrReplace(URL, "/files", "/files/" + Identifier);
URL = StrReplace(URL, "/files", "/files/" + Identifier);
Response = OPI_Tools.Patch(URL, Description, Headers, True, True);
Else
Response = OPI_Tools.Post(URL, Description, Headers, True, True);
EndIf;
UploadURL = Response.Headers["Location"];
If Not ValueIsFilled(UploadURL) Then
OPI_Tools.ProcessResponse(Response);
Return Response;
EndIf;
UploadResponse = UploadFileInParts(Binary, UploadURL);
Response = ?(ValueIsFilled(UploadResponse), UploadResponse, Response);
Response = ?(ValueIsFilled(UploadResponse), UploadResponse, Response);
OPI_Tools.ProcessResponse(Response);
Return Response;
EndFunction
Function UploadFileInParts(Val Binary, Val UploadURL)
Response = "";
ChunkSize = 268435456;
BytesRead = 0;
Response = "";
ChunkSize = 268435456;
BytesRead = 0;
CurrentPosition = 0;
TotalSize = Binary.Size();
StrTotalSize = OPI_Tools.NumberToString(TotalSize);
DataReader = New DataReader(Binary);
SourceStream = DataReader.SourceStream();
TotalSize = Binary.Size();
StrTotalSize = OPI_Tools.NumberToString(TotalSize);
DataReader = New DataReader(Binary);
SourceStream = DataReader.SourceStream();
WHile BytesRead < TotalSize Do
BytesRead = SourceStream.CurrentPosition();
Result = DataReader.Read(ChunkSize);
CurrentData = Result.GetBinaryData();
CurrentSize = CurrentData.Size();
NextPosition = CurrentPosition + CurrentSize - 1;
BytesRead = SourceStream.CurrentPosition();
Result = DataReader.Read(ChunkSize);
CurrentData = Result.GetBinaryData();
CurrentSize = CurrentData.Size();
NextPosition = CurrentPosition + CurrentSize - 1;
If Not ValueIsFilled(CurrentData) Then
Break;
EndIf;
StreamHeader = "bytes "
+ OPI_Tools.NumberToString(CurrentPosition)
+ "-"
+ OPI_Tools.NumberToString(NextPosition)
+ "/"
+ "-"
+ OPI_Tools.NumberToString(NextPosition)
+ "/"
+ StrTotalSize;
AdditionalHeaders = New Map;
AdditionalHeaders.Insert("Content-Length", OPI_Tools.NumberToString(CurrentSize));
AdditionalHeaders.Insert("Content-Range" , StreamHeader);
AdditionalHeaders.Insert("Content-Type" , "application/octet-stream");
AdditionalHeaders.Insert("Content-Range" , StreamHeader);
AdditionalHeaders.Insert("Content-Type" , "application/octet-stream");
Response = OPI_Tools.Put(UploadURL, CurrentData, AdditionalHeaders, False, True);
CheckResult = CheckPartUpload(Response, StrTotalSize, AdditionalHeaders, UploadURL, CurrentPosition);
If ValueIsFilled(CheckResult) Then
Return CheckResult;
EndIf;
// !OInt KB = 1024;
// !OInt MB = KB * KB;
// !OInt Message(OPI_Tools.ProgressInfo(CurrentPosition, TotalSize, "MB", MB));
// !OInt RunGarbageCollection();
// !OInt FreeObject(CurrentData);
EndDo;
Return Response;
EndFunction
Function CheckPartUpload(Response, StrTotalSize, AdditionalHeaders, UploadURL, CurrentPosition)
StartOfErrorCodes = 400;
EndOfFailureCodes = 600;
StartOfErrorCodes = 400;
EndOfFailureCodes = 600;
StartOfSuccessCodes = 200;
EndOfSuccessCodes = 300;
Redirection = 308;
EndOfSuccessCodes = 300;
Redirection = 308;
If Response.StatusCode >= StartOfErrorCodes And Response.StatusCode < EndOfFailureCodes Then
StreamHeader = "bytes */" + StrTotalSize;
AdditionalHeaders.Insert("Content-Range" , StreamHeader);
CheckResponse = OPI_Tools.Put(UploadURL, "", AdditionalHeaders, False, True);
If CheckResponse.StatusCode >= StartOfSuccessCodes And CheckResponse.StatusCode < EndOfSuccessCodes Then
OPI_Tools.ProcessResponse(CheckResponse);
Return CheckResponse;
ElsIf CheckResponse.StatusCode = Redirection Then
UploadedData = Response.Headers["Range"];
Else
OPI_Tools.ProcessResponse(Response);
Return Response;
EndIf;
Else
UploadedData = Response.Headers["Range"];
EndIf;
If Not ValueIsFilled(UploadedData) Then
OPI_Tools.ProcessResponse(Response);
Return Response;
EndIf;
UploadedData = StrReplace(UploadedData, "bytes=", "");
UploadedData = StrReplace(UploadedData, "bytes =", "");
ArrayOfInformation = StrSplit(UploadedData, "-", False);
PartsRequired = 2;
PartsRequired = 2;
If Not ArrayOfInformation.Count() = PartsRequired Then
OPI_Tools.ProcessResponse(Response);
Return Response;
EndIf;
CurrentPosition = Number(ArrayOfInformation[1]) + 1;
Return "";
EndFunction
#EndRegion

264
src/en/OPI/src/CommonModules/OPI_GoogleSheets/Module.bsl
View File

@ -43,90 +43,90 @@
// Create spreadsheet
// Creates a new spreadsheet
//
//
// Parameters:
// Token - String - Token - token
// Name - String - Name - title
// ArrayOfSheetNames - Array of String - Array of names to add new sheets to the spreadsheet - sheets
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CreateSpreadsheet(Val Token, Val Name, Val ArrayOfSheetNames) Export
OPI_TypeConversion.GetLine(Name);
OPI_TypeConversion.GetCollection(ArrayOfSheetNames);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets";
URL = "https://sheets.googleapis.com/v4/spreadsheets";
Properties = New Structure("title" , Name);
Sheets = New Array;
Sheets = New Array;
FillSheetArray(ArrayOfSheetNames, Sheets);
Parameters = New Structure;
OPI_Tools.AddField("properties", Properties, "Collection", Parameters);
OPI_Tools.AddField("sheets" , Sheets , "Collection", Parameters);
OPI_Tools.AddField("sheets" , Sheets , "Collection", Parameters);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Get spreadsheet
// Gets information about the spreadsheet by ID
//
//
// Parameters:
// Token - String - Token - token
// Identifier - String - Spreadsheet identifier - spreadsheet
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetSpreadsheet(Val Token, Val Identifier) Export
OPI_TypeConversion.GetLine(Identifier);
OPI_TypeConversion.GetLine(Identifier);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Identifier;
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Identifier;
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
// Change spreadsheet name
// Changes the name of the existing spreadsheet
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - SpreadsheetID - spreadsheet
// Name - String - New name - title
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function EditSpreadsheetTitle(Val Token, Val Spreadsheet, Val Name) Export
OPI_TypeConversion.GetLine(Spreadsheet);
OPI_TypeConversion.GetLine(Name);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
Change = New Structure("title", Name);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
Change = New Structure("title", Name);
ChangeRequest = New Structure("properties,fields", Change, "title");
Request = New Structure("updateSpreadsheetProperties", ChangeRequest);
Request = New Structure("updateSpreadsheetProperties", ChangeRequest);
ArrayOfRequests = New Array;
ArrayOfRequests.Add(Request);
Parameters = New Structure("requests", ArrayOfRequests);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
#EndRegion
@ -135,95 +135,95 @@ EndFunction
// Add sheet
// Adds a new sheet to the spreadsheet
//
//
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - Spreadsheet identifier - spreadsheet
// Name - String - NewSheetName - title
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function AddSheet(Val Token, Val Spreadsheet, Val Name) Export
OPI_TypeConversion.GetLine(Spreadsheet);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
Sheet = CreateSheet(Name);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
Sheet = CreateSheet(Name);
Requests = New Array;
Change = New Structure("addSheet", Sheet);
Change = New Structure("addSheet", Sheet);
Requests.Add(Change);
Parameters = New Structure("requests", Requests);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Delete sheet
// Deletes a sheet from the spreadsheet
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - Spreadsheet identifier - spreadsheet
// Sheet - String - IdentifierOfSheetToDelete - sheet
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function DeleteSheet(Val Token, Val Spreadsheet, Val Sheet) Export
OPI_TypeConversion.GetLine(Spreadsheet);
OPI_TypeConversion.GetLine(Sheet);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + ":batchUpdate";
Requests = New Array;
Sheet = New Structure("sheetId" , Sheet);
Change = New Structure("deleteSheet", Sheet);
Sheet = New Structure("sheetId" , Sheet);
Change = New Structure("deleteSheet", Sheet);
Requests.Add(Change);
Parameters = New Structure("requests", Requests);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Copy sheet
// Copies a sheet from one spreadsheet to another
//
//
// Parameters:
// Token - String - Token - token
// From - String - Source spreadsheet ID - from
// Target - String - Destination spreadsheet ID - to
// Sheet - String - CopiedSheetID - sheet
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function CopySheet(Val Token, Val From, Val Target, Val Sheet) Export
OPI_TypeConversion.GetLine(From);
OPI_TypeConversion.GetLine(Target);
OPI_TypeConversion.GetLine(Sheet);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/"
URL = "https://sheets.googleapis.com/v4/spreadsheets/"
+ From
+ "/sheets/"
+ Sheet
+ ":copyTo";
Parameters = New Structure("destinationSpreadsheetId", Target);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Parameters = New Structure("destinationSpreadsheetId", Target);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
#EndRegion
@ -232,14 +232,14 @@ EndFunction
// Set cell values
// Sets sheet cell values
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - SpreadsheetID - spreadsheet
// Spreadsheet - String - SpreadsheetID - spreadsheet
// ValueMapping - Map Of KeyAndValue - Fill data where the key is the cell name like A1 - data
// Sheet - String - Sheet name (first sheet by default) - sheetname
// MajorDimension - String - Main dimension when filling the array range - dim
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function SetCellValues(Val Token
@ -247,90 +247,90 @@ Function SetCellValues(Val Token
, Val ValueMapping
, Val Sheet = ""
, Val MajorDimension = "COLUMNS") Export
OPI_TypeConversion.GetLine(Spreadsheet);
OPI_TypeConversion.GetCollection(ValueMapping);
If Not TypeOf(ValueMapping) = Type("Structure")
If Not TypeOf(ValueMapping) = Type("Structure")
And Not TypeOf(ValueMapping) = Type("Map") Then
Return "Failed to convert the structure of values to a collection";
EndIf;
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchUpdate";
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchUpdate";
DataArray = FormCellDataArray(ValueMapping, MajorDimension, Sheet);
Parameters = New Structure("data,valueInputOption", DataArray, "USER_ENTERED");
Response = OPI_Tools.Post(URL, Parameters, Headers);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Clear cells
// Clears the value in cells
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - SpreadsheetID - spreadsheet
// CellsArray - Array of String - Array of cells like A1 to be cleared - cells
// Sheet - String - Sheet name (first sheet by default) - sheetname
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function ClearCells(Val Token, Val Spreadsheet, Val CellsArray, Val Sheet = "") Export
OPI_TypeConversion.GetLine(Spreadsheet);
OPI_TypeConversion.GetCollection(CellsArray);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchClear";
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchClear";
FormCellNameArray(CellsArray, Sheet);
Parameters = New Structure("ranges", CellsArray);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Response = OPI_Tools.Post(URL, Parameters, Headers);
Return Response;
EndFunction
// Get cell values
// Gets cell values of the table
//
//
// Parameters:
// Token - String - Token - token
// Spreadsheet - String - SpreadsheetID - spreadsheet
// CellsArray - Array of String - Array of A1 type cells to get (whole sheet if not filled) - cells
// Sheet - String - Sheet name (first sheet by default) - sheetname
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetCellValues(Val Token, Val Spreadsheet, Val CellsArray = "", Val Sheet = "") Export
OPI_TypeConversion.GetLine(Spreadsheet);
Headers = OPI_GoogleWorkspace.GetAuthorizationHeader(Token);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchGet";
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Spreadsheet + "/values:batchGet";
If ValueIsFilled(CellsArray) Then
OPI_TypeConversion.GetCollection(CellsArray);
OPI_TypeConversion.GetCollection(CellsArray);
FormCellNameArray(CellsArray, Sheet);
First = True;
First = True;
For Each Cell In CellsArray Do
Delimiter = ?(First, "?", "&");
URL = URL + Delimiter + "ranges=" + Cell;
First = False;
URL = URL + Delimiter + "ranges =" + Cell;
First = False;
EndDo;
Else
URL = URL + "?ranges='" + Sheet + "'";
URL = URL + "?ranges ='" + Sheet + "'";
EndIf;
Response = OPI_Tools.Get(URL, , Headers);
Return Response;
EndFunction
#EndRegion
@ -340,75 +340,75 @@ EndFunction
#Region Private
Procedure FillSheetArray(Val ArrayOfNames, SheetArray)
For Each SheetName In ArrayOfNames Do
Sheet = CreateSheet(SheetName);
SheetArray.Add(Sheet);
EndDo;
EndProcedure
Procedure AddSheetName(Cell, Val Sheet)
If ValueIsFilled(Sheet) Then
Cell = "'" + Sheet + "'!" + Cell;
EndIf;
EndProcedure
Function CreateSheet(Val Name)
OPI_TypeConversion.GetLine(Name);
SheetProperties = New Structure("title" , Name);
Sheet = New Structure("properties", SheetProperties);
Sheet = New Structure("properties", SheetProperties);
Return Sheet;
EndFunction
Function FormCellDataArray(Val ValueStructure, Val MajorDimension, Val Sheet)
OPI_TypeConversion.GetLine(Sheet);
DataArray = New Array;
For Each CellData In ValueStructure Do
CurrentValue = CellData.Value;
CurrentKey = CellData.Key;
CurrentKey = CellData.Key;
AddSheetName(CurrentKey, Sheet);
OPI_TypeConversion.GetArray(CurrentValue);
CurrentData = New Map;
CurrentData = New Map;
CurrentArray = New Array;
CurrentArray.Add(CurrentValue);
OPI_Tools.AddField("range" , CurrentKey , "String", CurrentData);
OPI_Tools.AddField("values" , CurrentArray , "Array", CurrentData);
OPI_Tools.AddField("range" , CurrentKey , "String", CurrentData);
OPI_Tools.AddField("values" , CurrentArray , "Array" , CurrentData);
OPI_Tools.AddField("majorDimension", MajorDimension, "String", CurrentData);
DataArray.Add(CurrentData);
EndDo;
Return DataArray;
EndFunction
Procedure FormCellNameArray(Val ArrayOfNames, Val Sheet)
OPI_TypeConversion.GetLine(Sheet);
For N = 0 To ArrayOfNames.UBound() Do
OPI_TypeConversion.GetLine(Sheet);
For N = 0 To ArrayOfNames.UBound() Do
AddSheetName(ArrayOfNames[N], Sheet);
EndDo;
EndProcedure
#EndRegion

84
src/en/OPI/src/CommonModules/OPI_GoogleWorkspace/Module.bsl
View File

@ -41,97 +41,97 @@
// Generate code retrieval link
// Returns URL for browser authorization
//
//
// Parameters:
// ClientID - String - Client ID - id
// Calendar - Boolean - Calendar methods permission - calendar
// Drive - Boolean - Drive methods permission - drive
// Sheets - Boolean - Sheets methods permission - sheets
//
//
// Returns:
// String - Code retrieval link
Function FormCodeRetrievalLink(Val ClientID
, Val Calendar = True
, Val Drive = True
, Val Sheets = True) Export
OPI_TypeConversion.GetLine(ClientID);
OPI_TypeConversion.GetBoolean(Calendar);
OPI_TypeConversion.GetBoolean(Sheets);
OPI_TypeConversion.GetBoolean(Drive);
URL = "https://accounts.google.com/o/oauth2/auth";
URLParameters = New Structure;
URLParameters.Insert("response_type", "code");
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("redirect_uri" , "http://localhost");
URLParameters.Insert("access_type" , "offline");
URLParameters.Insert("scope" , GetPermissionsList(Calendar, Drive, Sheets));
URLParameters.Insert("access_type" , "offline");
URLParameters.Insert("scope" , GetPermissionsList(Calendar, Drive, Sheets));
URL = URL + OPI_Tools.RequestParametersToString(URLParameters);
Return URL;
EndFunction
// Get token by code
// Gets token by code from browser authorization
//
//
// Parameters:
// ClientID - String - Client ID - id
// ClientSecret - String - Client secret - secret
// Code - String - Code from browser - code
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function GetTokenByCode(Val ClientID, Val ClientSecret, Val Code) Export
OPI_TypeConversion.GetLine(ClientID);
OPI_TypeConversion.GetLine(ClientSecret);
OPI_TypeConversion.GetLine(Code);
URL = "https://accounts.google.com/o/oauth2/token";
URLParameters = New Structure;
URLParameters.Insert("grant_type" , "authorization_code");
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("grant_type" , "authorization_code");
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("client_secret", ClientSecret);
URLParameters.Insert("redirect_uri" , "http://localhost");
URLParameters.Insert("code" , Code);
URLParameters.Insert("redirect_uri" , "http://localhost");
URLParameters.Insert("code" , Code);
Response = OPI_Tools.Post(URL, URLParameters, , False);
Return Response;
EndFunction
// Refresh token
// Updates token by Refresh token
//
//
// Parameters:
// ClientID - String - Client ID - id
// ClientSecret - String - Client secret - secret
// RefreshToken - String - Refresh token - refresh
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Google
Function RefreshToken(Val ClientID, Val ClientSecret, Val RefreshToken) Export
OPI_TypeConversion.GetLine(ClientID);
OPI_TypeConversion.GetLine(ClientSecret);
OPI_TypeConversion.GetLine(RefreshToken);
URL = "https://accounts.google.com/o/oauth2/token";
URLParameters = New Structure;
URLParameters.Insert("grant_type" , "refresh_token");
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("client_secret", ClientSecret);
URLParameters.Insert("grant_type" , "refresh_token");
URLParameters.Insert("client_id" , ClientID);
URLParameters.Insert("client_secret", ClientSecret);
URLParameters.Insert("refresh_token", RefreshToken);
Response = OPI_Tools.Post(URL, URLParameters, , False);
Return Response;
EndFunction
@ -141,14 +141,14 @@ EndFunction
#Region Internal
Function GetAuthorizationHeader(Val Token) Export
OPI_TypeConversion.GetLine(Token);
Headers = New Map;
Headers.Insert("Authorization", "Bearer " + Token);
Return Headers;
EndFunction
#EndRegion
@ -156,23 +156,23 @@ EndFunction
#Region ServiceProceduresAndFunctions
Function GetPermissionsList(Calendar, Drive, Sheets)
PermissionsArray = New Array;
If Calendar Then
PermissionsArray.Add("https://www.googleapis.com/auth/calendar");
EndIf;
If Drive Then
PermissionsArray.Add("https://www.googleapis.com/auth/drive");
EndIf;
If Sheets Then
PermissionsArray.Add("https://www.googleapis.com/auth/spreadsheets");
EndIf;
Return StrConcat(PermissionsArray, " ");
EndFunction
#EndRegion

554
src/en/OPI/src/CommonModules/OPI_Notion/Module.bsl
View File

File diff suppressed because it is too large Load Diff

652
src/en/OPI/src/CommonModules/OPI_Slack/Module.bsl
View File

File diff suppressed because it is too large Load Diff

640
src/en/OPI/src/CommonModules/OPI_Telegram/Module.bsl
View File

File diff suppressed because it is too large Load Diff

518
src/en/OPI/src/CommonModules/OPI_TestDataRetrieval/Module.bsl
View File

@ -46,404 +46,404 @@
#Region Internal
Function GetTestingSectionMapping() Export
StandardDependencies = "[Decode, Build]";
GoogleDependencies = "Testing-GoogleWorkspace";
GoogleDependencies = "Testing-GoogleWorkspace";
Sections = New Structure;
Sections.Insert("Telegram" , StandardDependencies);
Sections.Insert("VK" , StandardDependencies);
Sections.Insert("Viber" , StandardDependencies);
Sections.Insert("Twitter" , StandardDependencies);
Sections.Insert("YandexDisk" , StandardDependencies);
Sections.Insert("Telegram" , StandardDependencies);
Sections.Insert("VK" , StandardDependencies);
Sections.Insert("Viber" , StandardDependencies);
Sections.Insert("Twitter" , StandardDependencies);
Sections.Insert("YandexDisk" , StandardDependencies);
Sections.Insert("GoogleWorkspace", StandardDependencies);
Sections.Insert("GoogleCalendar" , GoogleDependencies);
Sections.Insert("GoogleDrive" , GoogleDependencies);
Sections.Insert("GoogleSheets" , GoogleDependencies);
Sections.Insert("Notion" , StandardDependencies);
Sections.Insert("Slack" , StandardDependencies);
Sections.Insert("Airtable" , StandardDependencies);
Sections.Insert("Dropbox" , StandardDependencies);
Sections.Insert("Bitrix24" , StandardDependencies);
Sections.Insert("GoogleCalendar" , GoogleDependencies);
Sections.Insert("GoogleDrive" , GoogleDependencies);
Sections.Insert("GoogleSheets" , GoogleDependencies);
Sections.Insert("Notion" , StandardDependencies);
Sections.Insert("Slack" , StandardDependencies);
Sections.Insert("Airtable" , StandardDependencies);
Sections.Insert("Dropbox" , StandardDependencies);
Sections.Insert("Bitrix24" , StandardDependencies);
Return Sections;
EndFunction
Function GetTestTable() Export
Telegram = "Telegram";
Telegram = "Telegram";
VKontakte = "VK";
YDisk = "YandexDisk";
Calendar = "GoogleCalendar";
Twitter = "Twitter";
Viber = "Viber";
Drive = "GoogleDrive";
VSpace = "GoogleWorkspace";
Notion = "Notion";
Slack = "Slack";
Tables = "GoogleSheets";
AirT = "Airtable";
Dropbox = "Dropbox";
Bitrix = "Bitrix24";
YDisk = "YandexDisk";
Calendar = "GoogleCalendar";
Twitter = "Twitter";
Viber = "Viber";
Drive = "GoogleDrive";
VSpace = "GoogleWorkspace";
Notion = "Notion";
Slack = "Slack";
Tables = "GoogleSheets";
AirT = "Airtable";
Dropbox = "Dropbox";
Bitrix = "Bitrix24";
TestTable = New ValueTable;
TestTable.Columns.Add("Method");
TestTable.Columns.Add("Synonym");
TestTable.Columns.Add("Section");
NewTest(TestTable, "TelegramAPI_GetBotInfo" , "Get bot information" , Telegram);
NewTest(TestTable, "TelegramAPI_GetUpdates" , "Get updates" , Telegram);
NewTest(TestTable, "TelegramAPI_SetWebhook" , "Set Webhook" , Telegram);
NewTest(TestTable, "TelegramAPI_SendTextMessage" , "Send text message" , Telegram);
NewTest(TestTable, "TelegramAPI_SendImage" , "Send image" , Telegram);
NewTest(TestTable, "TelegramAPI_SendVideo" , "Send video" , Telegram);
NewTest(TestTable, "TelegramAPI_SendAudio" , "Send audio" , Telegram);
NewTest(TestTable, "TelegramAPI_SendDocument" , "Send document" , Telegram);
NewTest(TestTable, "TelegramAPI_SendGIF" , "Send GIF" , Telegram);
NewTest(TestTable, "TelegramAPI_SendMediaGroup" , "Send mediagroup" , Telegram);
NewTest(TestTable, "TelegramAPI_SendLocation" , "Send location" , Telegram);
NewTest(TestTable, "TelegramAPI_SendContact" , "Send contact" , Telegram);
NewTest(TestTable, "TelegramAPI_SendPoll" , "Send poll" , Telegram);
NewTest(TestTable, "TelegramAPI_ForwardMessage" , "Forward message" , Telegram);
NewTest(TestTable, "TelegramAPI_BanUnban" , "Ban/Unban" , Telegram);
NewTest(TestTable, "TelegramAPI_CreateInvitationLink" , "Create invitation link" , Telegram);
NewTest(TestTable, "TelegramAPI_PinUnpinMessage" , "Pin/Unpin message" , Telegram);
NewTest(TestTable, "TelegramAPI_GetMemberCount" , "Get participant count" , Telegram);
NewTest(TestTable, "TelegramAPI_GetForumAvatarsList", "Get forum avatars list", Telegram);
NewTest(TestTable, "TelegramAPI_GetBotInfo" , "Get bot information" , Telegram);
NewTest(TestTable, "TelegramAPI_GetUpdates" , "Get updates" , Telegram);
NewTest(TestTable, "TelegramAPI_SetWebhook" , "Set Webhook" , Telegram);
NewTest(TestTable, "TelegramAPI_SendTextMessage" , "Send text message" , Telegram);
NewTest(TestTable, "TelegramAPI_SendImage" , "Send image" , Telegram);
NewTest(TestTable, "TelegramAPI_SendVideo" , "Send video" , Telegram);
NewTest(TestTable, "TelegramAPI_SendAudio" , "Send audio" , Telegram);
NewTest(TestTable, "TelegramAPI_SendDocument" , "Send document" , Telegram);
NewTest(TestTable, "TelegramAPI_SendGIF" , "Send GIF" , Telegram);
NewTest(TestTable, "TelegramAPI_SendMediaGroup" , "Send mediagroup" , Telegram);
NewTest(TestTable, "TelegramAPI_SendLocation" , "Send location" , Telegram);
NewTest(TestTable, "TelegramAPI_SendContact" , "Send contact" , Telegram);
NewTest(TestTable, "TelegramAPI_SendPoll" , "Send poll" , Telegram);
NewTest(TestTable, "TelegramAPI_ForwardMessage" , "Forward message" , Telegram);
NewTest(TestTable, "TelegramAPI_BanUnban" , "Ban/Unban" , Telegram);
NewTest(TestTable, "TelegramAPI_CreateInvitationLink" , "Create invitation link" , Telegram);
NewTest(TestTable, "TelegramAPI_PinUnpinMessage" , "Pin/Unpin message" , Telegram);
NewTest(TestTable, "TelegramAPI_GetMemberCount" , "Get participant count" , Telegram);
NewTest(TestTable, "TelegramAPI_GetForumAvatarsList" , "Get forum avatars list" , Telegram);
NewTest(TestTable, "TelegramAPI_CreateDeleteForumTopic" , "Create/Delete forum topic" , Telegram);
NewTest(TestTable, "TelegramAPI_ChangeMainTopicName" , "Change main topic name" , Telegram);
NewTest(TestTable, "TelegramAPI_HideShowMainTopic" , "Hide/Show main topic" , Telegram);
NewTest(TestTable, "VKAPI_CreateTokenLink" , "Create token retrieval link", VKontakte);
NewTest(TestTable, "VKAPI_CreateDeletePost" , "Create/Delete post" , VKontakte);
NewTest(TestTable, "VKAPI_CreateCompositePost" , "Create/Delete composite post" , VKontakte);
NewTest(TestTable, "VKAPI_CreatePoll" , "Create poll" , VKontakte);
NewTest(TestTable, "VKAPI_SaveDeleteImage" , "Add/Delete image" , VKontakte);
NewTest(TestTable, "VKAPI_CreateStory" , "Create story" , VKontakte);
NewTest(TestTable, "VKAPI_DiscussionMethods" , "Actions with discussions" , VKontakte);
NewTest(TestTable, "VKAPI_LikeRepostComment" , "Like/Repost/Comment" , VKontakte);
NewTest(TestTable, "VKAPI_GetStatistics" , "Get statistics" , VKontakte);
NewTest(TestTable, "VKAPI_GetPostStatistics" , "Get post statistics" , VKontakte);
NewTest(TestTable, "VKAPI_CreateAdCampaign" , "Create advertising campaign" , VKontakte);
NewTest(TestTable, "VKAPI_SendMessage" , "Send message" , VKontakte);
NewTest(TestTable, "VKAPI_GetProductCategories" , "Get product categories" , VKontakte);
NewTest(TestTable, "VKAPI_CreateProductSelection" , "Create product and selection" , VKontakte);
NewTest(TestTable, "TelegramAPI_ChangeMainTopicName" , "Change main topic name" , Telegram);
NewTest(TestTable, "TelegramAPI_HideShowMainTopic" , "Hide/Show main topic" , Telegram);
NewTest(TestTable, "VKAPI_CreateTokenLink" , "Create token retrieval link" , VKontakte);
NewTest(TestTable, "VKAPI_CreateDeletePost" , "Create/Delete post" , VKontakte);
NewTest(TestTable, "VKAPI_CreateCompositePost" , "Create/Delete composite post" , VKontakte);
NewTest(TestTable, "VKAPI_CreatePoll" , "Create poll" , VKontakte);
NewTest(TestTable, "VKAPI_SaveDeleteImage" , "Add/Delete image" , VKontakte);
NewTest(TestTable, "VKAPI_CreateStory" , "Create story" , VKontakte);
NewTest(TestTable, "VKAPI_DiscussionMethods" , "Actions with discussions" , VKontakte);
NewTest(TestTable, "VKAPI_LikeRepostComment" , "Like/Repost/Comment" , VKontakte);
NewTest(TestTable, "VKAPI_GetStatistics" , "Get statistics" , VKontakte);
NewTest(TestTable, "VKAPI_GetPostStatistics" , "Get post statistics" , VKontakte);
NewTest(TestTable, "VKAPI_CreateAdCampaign" , "Create advertising campaign" , VKontakte);
NewTest(TestTable, "VKAPI_SendMessage" , "Send message" , VKontakte);
NewTest(TestTable, "VKAPI_GetProductCategories" , "Get product categories" , VKontakte);
NewTest(TestTable, "VKAPI_CreateProductSelection" , "Create product and selection" , VKontakte);
NewTest(TestTable, "VKAPI_CreateProductWithProperties" , "Create product with properties" , VKontakte);
NewTest(TestTable, "VKAPI_GetProductList" , "Get product list" , VKontakte);
NewTest(TestTable, "VKAPI_GetSelectionList" , "Get selection list" , VKontakte);
NewTest(TestTable, "VKAPI_GetPropertyList" , "Get property list" , VKontakte);
NewTest(TestTable, "VKAPI_GetOrderList" , "Get order list" , VKontakte);
NewTest(TestTable, "VKAPI_UploadVideo" , "Upload video" , VKontakte);
NewTest(TestTable, "YDisk_GetDiskInfo" , "Get disk information" , YDisk);
NewTest(TestTable, "YDisk_CreateFolder" , "Create folder" , YDisk);
NewTest(TestTable, "YDisk_UploadByUrlAndGetObject", "Upload by URL and get" , YDisk);
NewTest(TestTable, "YDisk_UploadDeleteFile" , "Upload/Delete file" , YDisk);
NewTest(TestTable, "YDisk_CreateObjectCopy" , "Create object copy" , YDisk);
NewTest(TestTable, "YDisk_GetDownloadLink" , "Get download link" , YDisk);
NewTest(TestTable, "YDisk_GetFileList" , "Get list of files" , YDisk);
NewTest(TestTable, "YDisk_MoveObject" , "Move object" , YDisk);
NewTest(TestTable, "YDisk_PublicObjectActions" , "Actions with public objects", YDisk);
NewTest(TestTable, "YDisk_GetPublishedList" , "Get published list" , YDisk);
NewTest(TestTable, "VKAPI_GetProductList" , "Get product list" , VKontakte);
NewTest(TestTable, "VKAPI_GetSelectionList" , "Get selection list" , VKontakte);
NewTest(TestTable, "VKAPI_GetPropertyList" , "Get property list" , VKontakte);
NewTest(TestTable, "VKAPI_GetOrderList" , "Get order list" , VKontakte);
NewTest(TestTable, "VKAPI_UploadVideo" , "Upload video" , VKontakte);
NewTest(TestTable, "YDisk_GetDiskInfo" , "Get disk information" , YDisk);
NewTest(TestTable, "YDisk_CreateFolder" , "Create folder" , YDisk);
NewTest(TestTable, "YDisk_UploadByUrlAndGetObject", "Upload by URL and get" , YDisk);
NewTest(TestTable, "YDisk_UploadDeleteFile" , "Upload/Delete file" , YDisk);
NewTest(TestTable, "YDisk_CreateObjectCopy" , "Create object copy" , YDisk);
NewTest(TestTable, "YDisk_GetDownloadLink" , "Get download link" , YDisk);
NewTest(TestTable, "YDisk_GetFileList" , "Get list of files" , YDisk);
NewTest(TestTable, "YDisk_MoveObject" , "Move object" , YDisk);
NewTest(TestTable, "YDisk_PublicObjectActions" , "Actions with public objects", YDisk);
NewTest(TestTable, "YDisk_GetPublishedList" , "Get published list" , YDisk);
NewTest(TestTable, "GV_GetAuthorizationLink" , "Get authorization link" , VSpace);
NewTest(TestTable, "GV_GetToken" , "Get token" , VSpace);
NewTest(TestTable, "GV_UpdateToken" , "Refresh token" , VSpace);
NewTest(TestTable, "GC_GetCalendarList" , "Get list of calendars" , Calendar);
NewTest(TestTable, "GV_GetToken" , "Get token" , VSpace);
NewTest(TestTable, "GV_UpdateToken" , "Refresh token" , VSpace);
NewTest(TestTable, "GC_GetCalendarList" , "Get list of calendars" , Calendar);
NewTest(TestTable, "GC_CreateDeleteCalendar" , "Create/Delete calendar" , Calendar);
NewTest(TestTable, "GC_CreateDeleteEvent" , "Create/Delete event" , Calendar);
NewTest(TestTable, "GC_GetEventList" , "Get list of events" , Calendar);
NewTest(TestTable, "GD_GetCatalogList" , "Get list of directories" , Drive);
NewTest(TestTable, "GD_UploadDeleteFile" , "Upload/Delete file" , Drive);
NewTest(TestTable, "GD_CreateDeleteComment" , "Create/Delete Comment" , Drive);
NewTest(TestTable, "GD_CreateCatalog" , "Create/Delete catalog" , Drive);
NewTest(TestTable, "GT_CreateTable" , "Create table" , Tables);
NewTest(TestTable, "GT_GetTable" , "Get table" , Tables);
NewTest(TestTable, "GC_CreateDeleteEvent" , "Create/Delete event" , Calendar);
NewTest(TestTable, "GC_GetEventList" , "Get list of events" , Calendar);
NewTest(TestTable, "GD_GetCatalogList" , "Get list of directories" , Drive);
NewTest(TestTable, "GD_UploadDeleteFile" , "Upload/Delete file" , Drive);
NewTest(TestTable, "GD_CreateDeleteComment" , "Create/Delete Comment" , Drive);
NewTest(TestTable, "GD_CreateCatalog" , "Create/Delete catalog" , Drive);
NewTest(TestTable, "GT_CreateTable" , "Create table" , Tables);
NewTest(TestTable, "GT_GetTable" , "Get table" , Tables);
NewTest(TestTable, "GT_FillClearCells" , "Fill/Clear cells" , Tables);
NewTest(TestTable, "Twitter_GetAuthorizationLink" , "Get authorization link" , Twitter);
NewTest(TestTable, "Twitter_UpdateToken" , "Refresh token" , Twitter);
NewTest(TestTable, "Twitter_CreateTextTweet" , "Text tweet" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithImage" , "Tweet with image" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithVideo" , "Tweet with video" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithGif" , "Tweet with gif" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithPoll" , "Tweet with poll" , Twitter);
NewTest(TestTable, "Viber_GetChannelInfo" , "Get channel info" , Viber);
NewTest(TestTable, "Viber_GetUserData" , "Get user data" , Viber);
NewTest(TestTable, "Viber_GetOnlineUsers" , "Get online users" , Viber);
NewTest(TestTable, "Twitter_UpdateToken" , "Refresh token" , Twitter);
NewTest(TestTable, "Twitter_CreateTextTweet" , "Text tweet" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithImage" , "Tweet with image" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithVideo" , "Tweet with video" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithGif" , "Tweet with gif" , Twitter);
NewTest(TestTable, "Twitter_CreateTweetWithPoll" , "Tweet with poll" , Twitter);
NewTest(TestTable, "Viber_GetChannelInfo" , "Get channel info" , Viber);
NewTest(TestTable, "Viber_GetUserData" , "Get user data" , Viber);
NewTest(TestTable, "Viber_GetOnlineUsers" , "Get online users" , Viber);
NewTest(TestTable, "Viber_SendTextMessage" , "Send text message" , Viber);
NewTest(TestTable, "Viber_SendImage" , "Send image" , Viber);
NewTest(TestTable, "Viber_SendFile" , "SendFile" , Viber);
NewTest(TestTable, "Viber_SendContact" , "Send contact" , Viber);
NewTest(TestTable, "Viber_SendLocation" , "Send location" , Viber);
NewTest(TestTable, "Viber_SendLink" , "Send link" , Viber);
NewTest(TestTable, "Notion_CreatePage" , "Create page" , Notion);
NewTest(TestTable, "Notion_CreateEditDatabase" , "Create/Edit database" , Notion);
NewTest(TestTable, "Notion_GetPageInfo" , "Get page info" , Notion);
NewTest(TestTable, "Notion_GetDatabaseInfo" , "Get database info" , Notion);
NewTest(TestTable, "Viber_SendImage" , "Send image" , Viber);
NewTest(TestTable, "Viber_SendFile" , "SendFile" , Viber);
NewTest(TestTable, "Viber_SendContact" , "Send contact" , Viber);
NewTest(TestTable, "Viber_SendLocation" , "Send location" , Viber);
NewTest(TestTable, "Viber_SendLink" , "Send link" , Viber);
NewTest(TestTable, "Notion_CreatePage" , "Create page" , Notion);
NewTest(TestTable, "Notion_CreateEditDatabase" , "Create/Edit database" , Notion);
NewTest(TestTable, "Notion_GetPageInfo" , "Get page info" , Notion);
NewTest(TestTable, "Notion_GetDatabaseInfo" , "Get database info" , Notion);
NewTest(TestTable, "Notion_CreatePageInDatabase" , "Create page in database" , Notion);
NewTest(TestTable, "Notion_EditPageProperties" , "Edit page properties" , Notion);
NewTest(TestTable, "Notion_CreateDeleteBlock" , "Create/Delete block" , Notion);
NewTest(TestTable, "Notion_GetUsers" , "Get users" , Notion);
NewTest(TestTable, "Notion_GetUserData" , "Get user data" , Notion);
NewTest(TestTable, "Slack_GetBotInfo" , "Get bot information" , Slack);
NewTest(TestTable, "Slack_GetUserList" , "Get user list" , Slack);
NewTest(TestTable, "Slack_GetRegionList" , "Get region list" , Slack);
NewTest(TestTable, "Slack_SendDeleteMessage" , "Send/Delete message" , Slack);
NewTest(TestTable, "Slack_SendDeleteEphemeral" , "Send/Delete ephemeral" , Slack);
NewTest(TestTable, "Slack_GetScheduledMessages" , "Get scheduled messages" , Slack);
NewTest(TestTable, "Slack_CreateArchiveChannel" , "Create/Archive channel" , Slack);
NewTest(TestTable, "Slack_GetChannelList" , "Get channel list" , Slack);
NewTest(TestTable, "Slack_OpenCloseDialog" , "Open/Close dialog" , Slack);
NewTest(TestTable, "Slack_GetFileList" , "Get list of files" , Slack);
NewTest(TestTable, "Slack_UploadDeleteFile" , "Upload/Delete file" , Slack);
NewTest(TestTable, "Slack_GetExternalFileList" , "Get external file list" , Slack);
NewTest(TestTable, "Notion_EditPageProperties" , "Edit page properties" , Notion);
NewTest(TestTable, "Notion_CreateDeleteBlock" , "Create/Delete block" , Notion);
NewTest(TestTable, "Notion_GetUsers" , "Get users" , Notion);
NewTest(TestTable, "Notion_GetUserData" , "Get user data" , Notion);
NewTest(TestTable, "Slack_GetBotInfo" , "Get bot information" , Slack);
NewTest(TestTable, "Slack_GetUserList" , "Get user list" , Slack);
NewTest(TestTable, "Slack_GetRegionList" , "Get region list" , Slack);
NewTest(TestTable, "Slack_SendDeleteMessage" , "Send/Delete message" , Slack);
NewTest(TestTable, "Slack_SendDeleteEphemeral" , "Send/Delete ephemeral" , Slack);
NewTest(TestTable, "Slack_GetScheduledMessages" , "Get scheduled messages" , Slack);
NewTest(TestTable, "Slack_CreateArchiveChannel" , "Create/Archive channel" , Slack);
NewTest(TestTable, "Slack_GetChannelList" , "Get channel list" , Slack);
NewTest(TestTable, "Slack_OpenCloseDialog" , "Open/Close dialog" , Slack);
NewTest(TestTable, "Slack_GetFileList" , "Get list of files" , Slack);
NewTest(TestTable, "Slack_UploadDeleteFile" , "Upload/Delete file" , Slack);
NewTest(TestTable, "Slack_GetExternalFileList" , "Get external file list" , Slack);
NewTest(TestTable, "Slack_UploadDeleteExternalFile" , "Upload/Delete external file" , Slack);
NewTest(TestTable, "AT_CreateDatabase" , "Create/Edit database" , AirT);
NewTest(TestTable, "AT_CreateTable" , "Create/Edit table" , AirT);
NewTest(TestTable, "AT_CreateField" , "Create/Edit field" , AirT);
NewTest(TestTable, "AT_CreateDatabase" , "Create/Edit database" , AirT);
NewTest(TestTable, "AT_CreateTable" , "Create/Edit table" , AirT);
NewTest(TestTable, "AT_CreateField" , "Create/Edit field" , AirT);
NewTest(TestTable, "AT_CreateDeleteRecords" , "Create/Delete records" , AirT);
NewTest(TestTable, "DropboxAPI_GetUpdateToken" , "Get/Update token" , Dropbox);
NewTest(TestTable, "DropboxAPI_UploadFile" , "Upload file" , Dropbox);
NewTest(TestTable, "DropboxAPI_UploadFileByURL" , "Upload file by URL" , Dropbox);
NewTest(TestTable, "DropboxAPI_CreateFolder" , "Create folder" , Dropbox);
NewTest(TestTable, "DropboxAPI_CreateDeleteTag" , "Create/Delete tag" , Dropbox);
NewTest(TestTable, "DropboxAPI_GetAccount" , "Get account data" , Dropbox);
NewTest(TestTable, "DropboxAPI_AccessManagement" , "Access management" , Dropbox);
NewTest(TestTable, "DropboxAPI_GetUpdateToken" , "Get/Update token" , Dropbox);
NewTest(TestTable, "DropboxAPI_UploadFile" , "Upload file" , Dropbox);
NewTest(TestTable, "DropboxAPI_UploadFileByURL" , "Upload file by URL" , Dropbox);
NewTest(TestTable, "DropboxAPI_CreateFolder" , "Create folder" , Dropbox);
NewTest(TestTable, "DropboxAPI_CreateDeleteTag" , "Create/Delete tag" , Dropbox);
NewTest(TestTable, "DropboxAPI_GetAccount" , "Get account data" , Dropbox);
NewTest(TestTable, "DropboxAPI_AccessManagement" , "Access management" , Dropbox);
NewTest(TestTable, "DropboxAPI_GetFolderFileList" , "Get list of folder files" , Dropbox);
NewTest(TestTable, "B24_TokenManagment" , "Token management" , Bitrix);
NewTest(TestTable, "B24_ServerTime" , "Server time" , Bitrix);
NewTest(TestTable, "B24_PostsManagment" , "Posts managment" , Bitrix);
NewTest(TestTable, "B24_TaskManagment" , "Tasks managment" , Bitrix);
NewTest(TestTable, "B24_CommentsManagment" , "Comments managment" , Bitrix);
NewTest(TestTable, "B24_WorkingWithDrive" , "Working with drive" , Bitrix);
NewTest(TestTable, "B24_Kanban" , "Kanban" , Bitrix);
NewTest(TestTable, "B24_Timekeeping" , "Timekeeping" , Bitrix);
NewTest(TestTable, "B24_ChatManagment" , "Chats works" , Bitrix);
NewTest(TestTable, "B24_TokenManagment" , "Token management" , Bitrix);
NewTest(TestTable, "B24_ServerTime" , "Server time" , Bitrix);
NewTest(TestTable, "B24_PostsManagment" , "Posts managment" , Bitrix);
NewTest(TestTable, "B24_TaskManagment" , "Tasks managment" , Bitrix);
NewTest(TestTable, "B24_CommentsManagment" , "Comments managment" , Bitrix);
NewTest(TestTable, "B24_WorkingWithDrive" , "Working with drive" , Bitrix);
NewTest(TestTable, "B24_Kanban" , "Kanban" , Bitrix);
NewTest(TestTable, "B24_Timekeeping" , "Timekeeping" , Bitrix);
NewTest(TestTable, "B24_ChatManagment" , "Chats works" , Bitrix);
NewTest(TestTable, "B24_NotificationsManagment" , "Notifications managment" , Bitrix);
Return TestTable;
EndFunction
EndFunction
Function ExpectsThat(Value) Export
Try
Module = GetCommonModule("ЮТест");
Module = GetCommonModule("ЮТест");
Ожидаем = TypeOf(Module) = Type("CommonModule");
Return Module.ОжидаетЧто(Value);
Return Module.ОжидаетЧто(Value);
Except
Return Ожидаем.Что(Value);
EndTry;
EndFunction
Function FormYAXTests() Export
Module = GetCommonModule("ЮТТесты");
Sections = GetTestingSectionMapping();
Module = GetCommonModule("ЮТТесты");
Sections = GetTestingSectionMapping();
TestTable = GetTestTable();
For Each Section In Sections Do
CurrentSection = Section.Key;
Filter = New Structure("Section", CurrentSection);
SectionTests = TestTable.FindRows(Filter);
Filter = New Structure("Section", CurrentSection);
SectionTests = TestTable.FindRows(Filter);
Set = Module.ДобавитьТестовыйНабор(CurrentSection);
For Each Test In SectionTests Do
Set.ДобавитьСерверныйТест(Test.Method, Test.Synonym);
EndDo;
EndDo;
Return "";
EndFunction
Function FormAssertsTests() Export
TestTable = GetTestTable();
TestTable = GetTestTable();
ArrayOfTests = New Array;
For Each Test In TestTable Do
For Each Test In TestTable Do
ArrayOfTests.Add(Test.Method);
EndDo;
Return ArrayOfTests;
EndFunction
Function GetParameter(Parameter) Export
Function GetParameter(Parameter) Export
Path = DataFilePath();
Path = DataFilePath();
Return GetValueFromFile(Parameter, Path);
EndFunction
Function GetBinary(Parameter) Export
Path = DataFilePath();
Path = DataFilePath();
LocalParameter = Parameter + "Local";
MainValue = GetValueFromFile(Parameter , Path);
LocalValue = GetValueFromFile(LocalParameter, Path);
MainValue = GetValueFromFile(Parameter , Path);
LocalValue = GetValueFromFile(LocalParameter, Path);
LocalFile = New File(LocalValue);
If LocalFile.Exists() Then
Value = New BinaryData(LocalValue);
Else
Value = MainValue;
EndIf;
If TypeOf(Value) = Type("String") Then
Value = GetFilePath(Value, LocalParameter);
Value = GetFilePath(Value, LocalParameter);
EndIf;
Return Value;
EndFunction
Function GetFilePath(Val Path, LocalParameter, Val SaveLocally = True) Export
If StrFind(Path, "http") > 0
If StrFind(Path, "http") > 0
Or StrFind(Path, "www") > 0 Then
TFN = GetTempFileName();
TFN = GetTempFileName();
FileCopy(Path, TFN);
Path = TFN;
Path = TFN;
Binary = New BinaryData(Path);
If SaveLocally Then
WriteParameter(LocalParameter, TFN);
Else
DeleteFiles(TFN);
EndIf;
Else
Binary = New BinaryData(Path);
EndIf;
Return Binary;
EndFunction
Procedure ParameterToCollection(Parameter, Collection) Export
Value = GetParameter(Parameter);
Collection.Insert(Parameter, Value);
EndProcedure
Procedure BinaryToCollection(Parameter, Collection) Export
Value = GetBinary(Parameter);
Collection.Insert(Parameter, Value);
EndProcedure
Procedure WriteParameter(Parameter, Value) Export
Path = DataFilePath();
Path = DataFilePath();
WriteParameterToFile(Parameter, Value, Path);
EndProcedure
Procedure WriteLog(Val Result, Val Method, Val Library = "") Export
Header = String(OPI_Tools.GetCurrentDate()) + " | " + Method;
Try
Data = OPI_Tools.JSONString(Result);
Except
Data = "Not JSON: " + String(Result);
EndTry;
Data = " " + Data;
Data = " " + Data;
Message(Header);
Message(Chars.LF);
Message(Data);
Message(Chars.LF);
Message("---------------------------------");
Message(Chars.LF);
If ValueIsFilled(Library) Then
WriteLogFile(Data, Method, Library);
EndIf;
EndProcedure
#EndRegion
#Region Private
Function GetValueFromFile(Parameter, Path)
Values = OPI_Tools.ReadJSONFile(Path);
Function GetValueFromFile(Parameter, Path)
Values = OPI_Tools.ReadJSONFile(Path);
Return ?(Values.Property(Parameter), Values[Parameter], "");
EndFunction
Function DataFilePath()
Path = "";
Path = "";
PossiblePaths = New Array;
PossiblePaths.Add("./data.json");
PossiblePaths.Add("C:\GDrive\Мой Диск\data.json");
PossiblePaths.Add("D:\GD\Мой Диск\data.json");
For Each PossiblePath In PossiblePaths Do
RepositoryFile = New File(PossiblePath);
If RepositoryFile.Exists() Then
Path = PossiblePath;
EndIf;
EndIf;
EndDo;
Return Path;
EndFunction
Function GetCommonModule(Val Name)
SetSafeMode(True);
Module = Eval(Name);
SetSafeMode(False);
Return Module;
SetSafeMode(True);
Module = Eval(Name);
SetSafeMode(False);
Return Module;
EndFunction
Procedure NewTest(ValueTable, Val Method, Val Synonym, Val Section)
NewTest = ValueTable.Add();
NewTest.Method = Method;
NewTest = ValueTable.Add();
NewTest.Method = Method;
NewTest.Synonym = Synonym;
NewTest.Section = Section;
EndProcedure
Procedure WriteParameterToFile(Val Parameter, Val Value, Val Path)
Values = OPI_Tools.ReadJSONFile(Path);
Values.Insert(Parameter, Value);
Record = New JSONWriter;
Record = New JSONWriter;
JSONWriterSettings = New JSONWriterSettings(JSONLineBreak.Auto, Chars.Tab);
Record.OpenFile(Path, , , JSONWriterSettings);
WriteJSON(Record, Values);
@ -452,37 +452,37 @@ Procedure WriteParameterToFile(Val Parameter, Val Value, Val Path)
EndProcedure
Procedure WriteLogFile(Val Data, Val Method, Val Library)
Try
LogPath = "./docs/ru/results";
LogPath = "./docs/ru/results";
LibraryLogPath = LogPath + "/" + Library;
LogDirectory = New File(LogPath);
If Not LogDirectory.Exists() Then
CreateDirectory(LogPath);
EndIf;
LibraryLogCatalog = New File(LibraryLogPath);
If Not LibraryLogCatalog.Exists() Then
CreateDirectory(LibraryLogPath);
EndIf;
FilePath = LibraryLogPath + "/" + Method + ".log";
LogFile = New File(FilePath);
LogFile = New File(FilePath);
If Not LogFile.Exists() Then
LogDocument = New TextDocument;
LogDocument.SetText(Data);
LogDocument.Write(FilePath);
EndIf;
Except
Message("Failed to write log file!: " + ErrorDescription());
Message("Failed to write log file!: " + ErrorDescription());
EndTry;
EndProcedure
#EndRegion

8520
src/en/OPI/src/CommonModules/OPI_Tests/Module.bsl
View File

File diff suppressed because it is too large Load Diff

754
src/en/OPI/src/CommonModules/OPI_Tools/Module.bsl
View File

File diff suppressed because it is too large Load Diff

538
src/en/OPI/src/CommonModules/OPI_Twitter/Module.bsl
View File

@ -48,83 +48,83 @@
// Get authorization link
// Forms a link for authorization via the browser
//
//
// Parameters:
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// String - URL for browser transition
Function GetAuthorizationLink(Parameters = "") Export
Parameters_ = GetStandardParameters(Parameters);
URLParameters = New Structure;
URLParameters.Insert("response_type" , "code");
URLParameters.Insert("client_id" , Parameters_["client_id"]);
URLParameters.Insert("redirect_uri" , Parameters_["redirect_uri"]);
URLParameters.Insert("scope" , Parameters_["scope"]);
URLParameters.Insert("state" , "state");
URLParameters.Insert("code_challenge" , "challenge");
URLParameters.Insert("response_type" , "code");
URLParameters.Insert("client_id" , Parameters_["client_id"]);
URLParameters.Insert("redirect_uri" , Parameters_["redirect_uri"]);
URLParameters.Insert("scope" , Parameters_["scope"]);
URLParameters.Insert("state" , "state");
URLParameters.Insert("code_challenge" , "challenge");
URLParameters.Insert("code_challenge_method", "plain");
URLParameters = OPI_Tools.RequestParametersToString(URLParameters);
Link = "https://twitter.com/i/oauth2/authorize" + URLParameters;
Link = "https://twitter.com/i/oauth2/authorize" + URLParameters;
Return Link;
EndFunction
// Get token
// Gets the token by the code received when authorizing using the link from GetAuthorizationLink
//
//
// Parameters:
// Code - String - Code obtained from authorization See GetAuthorizationLink - code
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function GetToken(Val Code, Val Parameters = "") Export
OPI_TypeConversion.GetLine(Code);
Parameters_ = GetStandardParameters(Parameters);
RequestParameters = New Structure;
RequestParameters.Insert("code" , Code);
RequestParameters.Insert("grant_type" , "authorization_code");
RequestParameters.Insert("client_id" , Parameters_["client_id"]);
RequestParameters.Insert("code" , Code);
RequestParameters.Insert("grant_type" , "authorization_code");
RequestParameters.Insert("client_id" , Parameters_["client_id"]);
RequestParameters.Insert("redirect_uri" , Parameters_["redirect_uri"]);
RequestParameters.Insert("code_verifier", "challenge");
Response = OPI_Tools.Post("https://api.twitter.com/2/oauth2/token"
, RequestParameters, , False);
Return Response;
EndFunction
// Refresh token
// Refresh token
// Updates the v2 token using the refresh_token
//
//
// Parameters:
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function RefreshToken(Val Parameters = "") Export
Parameters_ = GetStandardParameters(Parameters);
Refresh = "refresh_token";
Refresh = "refresh_token";
RequestParameters = New Structure;
RequestParameters.Insert(Refresh , Parameters_[Refresh]);
RequestParameters.Insert(Refresh , Parameters_[Refresh]);
RequestParameters.Insert("grant_type" , Refresh);
RequestParameters.Insert("client_id" , Parameters_["client_id"]);
RequestParameters.Insert("client_id" , Parameters_["client_id"]);
Response = OPI_Tools.Post("https://api.twitter.com/2/oauth2/token"
, RequestParameters, , False);
Return Response;
EndFunction
@ -133,23 +133,23 @@ EndFunction
// Method for insertion into an http service, the address of which is specified in redirect_uri
// Calls the token acquisition method, as for obtaining a token from the code received
// on redirect_uri after authorization via the browser is only 30 seconds
//
//
// Parameters:
// Request - HTTPServiceRequest - Request coming to the http service
//
//
// Returns:
// HTTPResponse, Arbitrary, BinaryData - Result of reading the JSON response from the server
Function HandleIncomingRequestAfterAuthorization(Request) Export
Code = Request.RequestParameters["code"];
Code = Request.RequestParameters["code"];
TokenResponse = GetToken(Code);
// BSLLS:CommentedCode-off
// Preferred token storage
// Constants.TwitterRefresh.Set(ResponseToken["refresh_token"]);
// Constants.TwitterToken.Set(ResponseToken["access_token"]);
// BSLLS:CommentedCode-on
Return TokenResponse;
EndFunction
@ -160,189 +160,189 @@ EndFunction
// !NOCLI
// Create custom tweet
//
//
// Parameters:
// Text - String - Tweet text
// MediaArray - Array of String, BinaryData - Array of binary data or file paths
// PollOptionsArray - Array of String - Array of poll options, if necessary
// PollDuration - String, Number - Poll duration if necessary (poll without duration is not created)
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreateCustomTweet(Val Text = ""
, Val MediaArray = ""
, Val PollOptionsArray = ""
, Val PollDuration = ""
, Val Parameters = "") Export
, Val Parameters = "") Export
OPI_TypeConversion.GetLine(Text);
OPI_TypeConversion.GetLine(PollDuration);
If ValueIsFilled(MediaArray) Then
OPI_TypeConversion.GetCollection(MediaArray);
EndIf;
If ValueIsFilled(PollOptionsArray) Then
OPI_TypeConversion.GetCollection(PollOptionsArray);
EndIf;
Parameters_ = GetStandardParameters(Parameters);
URL = "https://api.twitter.com/2/tweets";
Array = "Array";
Fields = New Map;
URL = "https://api.twitter.com/2/tweets";
Array = "Array";
Fields = New Map;
If ValueIsFilled(Text) Then
Fields.Insert("text", Text);
EndIf;
If TypeOf(PollOptionsArray) = Type(Array) And ValueIsFilled(PollDuration) Then
PollDuration = Number(PollDuration);
If PollOptionsArray.Count() > 0 Then
OptionStructure = New Structure("options,duration_minutes", PollOptionsArray, PollDuration);
Fields.Insert("poll", OptionStructure);
EndIf;
EndIf;
If TypeOf(MediaArray) = Type(Array) Then
If MediaArray.Count() > 0 Then
Fields.Insert("media", New Structure("media_ids", MediaArray));
EndIf;
EndIf;
Authorization = CreateAuthorizationHeaderV2(Parameters_);
Response = OPI_Tools.Post(URL, Fields, Authorization);
Response = OPI_Tools.Post(URL, Fields, Authorization);
Return Response;
EndFunction
// Create text tweet
// Creates a tweet without attachments
//
//
// Parameters:
// Text - String - Tweet text - text
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreateTextTweet(Val Text, Val Parameters = "") Export
Return CreateCustomTweet(Text, , , , Parameters);
Return CreateCustomTweet(Text, , , , Parameters);
EndFunction
// Create image tweet
// Creates a tweet with an image attachment
//
//
// Parameters:
// Text - String - Tweet text - text
// ImageArray - Array of String, BinaryData - Image files array - pictures
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreateImageTweet(Val Text, Val ImageArray, Val Parameters = "") Export
MediaArray = UploadAttachmentsArray(ImageArray, "photo", Parameters);
Return CreateCustomTweet(Text, MediaArray, , , Parameters);
Return CreateCustomTweet(Text, MediaArray, , , Parameters);
EndFunction
// Create gif tweet
// Creates a tweet with a gif attachment
//
//
// Parameters:
// Text - String - Tweet text - text
// GifsArray - Array of String, BinaryData - Gif files array - gifs
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreateGifTweet(Val Text, Val GifsArray, Val Parameters = "") Export
MediaArray = UploadAttachmentsArray(GifsArray, "animated_gif", Parameters);
Return CreateCustomTweet(Text, MediaArray, , , Parameters);
Return CreateCustomTweet(Text, MediaArray, , , Parameters);
EndFunction
// Create video tweet
// Creates a tweet with a video attachment
//
//
// Parameters:
// Text - String - Tweet text - text
// VideosArray - Array of String, BinaryData - Video files array - videos
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreateVideoTweet(Val Text, Val VideosArray, Val Parameters = "") Export
MediaArray = UploadAttachmentsArray(VideosArray, "video", Parameters);
Return CreateCustomTweet(Text, MediaArray, , , Parameters);
EndFunction
// Create poll tweet
// Creates a tweet with a poll
//
//
// Parameters:
// Text - String - Tweet text - text
// OptionArray - Array of String - Poll options array - options
// Duration - String, Number - Poll duration - duration
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Twitter
Function CreatePollTweet(Val Text, Val OptionArray, Val Duration, Val Parameters = "") Export
Return CreateCustomTweet(Text, , OptionArray, Duration, Parameters);
Return CreateCustomTweet(Text, , OptionArray, Duration, Parameters);
EndFunction
// Upload attachments array !NOCLI
// Uploads files to the server and returns their IDs
//
//
// Parameters:
// ArrayOfFiles - Array of String, BinaryData - Files array
// AttachmentsType - String - Attachments type
// Parameters - Structure Of String - See GetStandardParameters - auth - Authorization JSON or path to .json
//
//
// Returns:
// Array Of String - Media ID array
Function UploadAttachmentsArray(Val ArrayOfFiles, Val AttachmentsType, Val Parameters = "") Export
OPI_TypeConversion.GetLine(AttachmentsType);
OPI_TypeConversion.GetCollection(ArrayOfFiles);
MediaArray = New Array;
MediaArray = New Array;
Parameters_ = GetStandardParameters(Parameters);
MIS = "media_id_string";
MIS = "media_id_string";
If ValueIsFilled(ArrayOfFiles) Then
For Each SendingFile In ArrayOfFiles Do
OPI_TypeConversion.GetBinaryData(SendingFile);
Response = UploadMediaFile(SendingFile, AttachmentsType, Parameters_);
MediaID = Response[MIS];
MediaID = Response[MIS];
If Not ValueIsFilled(MediaID) Then
Return Response;
EndIf;
MediaArray.Add(MediaID);
EndDo;
EndIf;
Return MediaArray;
EndFunction
#EndRegion
@ -351,195 +351,195 @@ EndFunction
#Region Private
Function UploadMediaFile(Val File, Val Type, Val Parameters)
Function UploadMediaFile(Val File, Val Type, Val Parameters)
OPI_TypeConversion.GetBinaryData(File);
RequestType = "POST";
RequestType = "POST";
Parameters_ = GetStandardParameters(Parameters);
URL = "https://upload.twitter.com/1.1/media/upload.json";
If Type = "photo" Then
URL = "https://upload.twitter.com/1.1/media/upload.json";
If Type = "photo" Then
Fields = New Structure;
Fields.Insert("media_data" , Base64String(File));
Fields.Insert("media_data" , Base64String(File));
Fields.Insert("media_category", Type);
Authorization = CreateAuthorizationHeaderV1(Parameters_, Fields, RequestType, URL);
Response = OPI_Tools.Post(URL, Fields, Authorization, False);
Authorization = CreateAuthorizationHeaderV1(Parameters_, Fields, RequestType, URL);
Response = OPI_Tools.Post(URL, Fields, Authorization, False);
Else
Response = UploadMediaInParts(File, Type, RequestType, URL, Parameters_);
EndIf;
Return Response;
EndFunction
Function UploadMediaInParts(Val File, Val Type, Val RequestType, Val URL, Parameters)
Unit = 1024;
Count = 4;
Unit = 1024;
Count = 4;
MediaKey = "media_key";
MIS = "media_id_string";
Command = "command";
Size = File.Size();
MIS = "media_id_string";
Command = "command";
Size = File.Size();
MIMETypeMapping = New Map;
MIMETypeMapping.Insert("photo" , "image/jpeg");
MIMETypeMapping.Insert("video" , "video/mp4");
MIMETypeMapping.Insert("photo" , "image/jpeg");
MIMETypeMapping.Insert("video" , "video/mp4");
MIMETypeMapping.Insert("animated_gif", "image/gif");
ChunkSize = Count * Unit * Unit;
ChunkSize = Count * Unit * Unit;
ArrayReading = SplitBinaryData(File, ChunkSize);
Fields = New Structure;
Fields.Insert(Command , "INIT");
Fields.Insert("total_bytes" , OPI_Tools.NumberToString(Size));
Fields.Insert("media_type" , MIMETypeMapping.Get(Type));
Fields.Insert(Command , "INIT");
Fields.Insert("total_bytes" , OPI_Tools.NumberToString(Size));
Fields.Insert("media_type" , MIMETypeMapping.Get(Type));
Fields.Insert("media_category" , Type);
Authorization = CreateAuthorizationHeaderV1(Parameters, Fields, RequestType, URL);
InitializationResponse = OPI_Tools.Post(URL, Fields, Authorization, False);
InitializationKey = InitializationResponse[MediaKey];
InitializationID = InitializationResponse[MIS];
InitializationKey = InitializationResponse[MediaKey];
InitializationID = InitializationResponse[MIS];
If Not ValueIsFilled(InitializationKey) Or Not ValueIsFilled(InitializationID) Then
Return InitializationResponse;
Return InitializationResponse;
EndIf;
Counter = 0;
For Each Part In ArrayReading Do
Fields = New Structure;
Fields.Insert(Command , "APPEND");
Fields.Insert("media_key" , InitializationKey);
Fields.Insert(Command , "APPEND");
Fields.Insert("media_key" , InitializationKey);
Fields.Insert("segment_index" , OPI_Tools.NumberToString(Counter));
Fields.Insert("media" , Part);
Fields.Insert("media" , Part);
Authorization = CreateAuthorizationHeaderV1(Parameters, New Structure, RequestType, URL);
OPI_Tools.PostMultipart(URL, Fields, , , Authorization);
Counter = Counter + 1;
EndDo;
Fields = New Structure;
Fields.Insert(Command , "FINALIZE");
Fields.Insert(Command , "FINALIZE");
Fields.Insert("media_id", InitializationID);
ProcessingStatus = GetProcessingStatus(Parameters, Fields, URL);
If Not TypeOf(ProcessingStatus) = Type("String") Then
Return ProcessingStatus;
EndIf;
Response = WaitForProcessingCompletion(ProcessingStatus, InitializationID, URL, Parameters);
Return Response;
EndFunction
Function WaitForProcessingCompletion(Val ProcessingStatus, Val InitializationID, Val URL, Val Parameters)
ProcessingInfo = "processing_info";
Command = "command";
Fields = New Structure;
Fields.Insert(Command , "STATUS");
Command = "command";
Fields = New Structure;
Fields.Insert(Command , "STATUS");
Fields.Insert("media_id", InitializationID);
WHile String(ProcessingStatus) = "pending" Or String(ProcessingStatus) = "in_progress" Do
Authorization = CreateAuthorizationHeaderV1(Parameters, Fields, "GET", URL);
Response = OPI_Tools.Get(URL, Fields, Authorization);
Information = Response[ProcessingInfo];
Authorization = CreateAuthorizationHeaderV1(Parameters, Fields, "GET", URL);
Response = OPI_Tools.Get(URL, Fields, Authorization);
Information = Response[ProcessingInfo];
If Not ValueIsFilled(Information) Then
Return Response;
EndIf;
ProcessingStatus = Information["state"];
If Not ValueIsFilled(ProcessingStatus) Then
Return Response;
EndIf;
EndDo;
If ProcessingStatus = "failed" Then
Raise "Twitter could not process the video you uploaded";
EndIf;
Return Response;
EndFunction
Function GetStandardParameters(Val Parameters = "")
// The definition of the data required for the work is collected here.
// For Twitter, this is quite a significant set, which is due to the presence of 2 APIs at once,
// which, at the same time, are not created for different tasks, but are simply versions of each other.
// The current version of the API is v2 and it requires obtaining temporary tokens. Despite the fact,
// that Twitter insists on using this latest version, they somehow managed not to transfer
// file upload mechanism and some others from the old version - v1.1. Therefore, something needs to be done
// file upload mechanism and some others from the old version - v1.1. Therefore, something needs to be done
// on version 1.1, and something on 2: up to the point that they removed the ability to post tweets from v1.1,
// but only through it you can add a picture to the tweet. At the same time, their authentication methods and tokens are different
// The world gigacorporation of Elon Musk, by the way, a reminder ;)
// P.S The following is often referred to as the "Twitter Developer settings page" - this
// P.S The following is often referred to as the "Twitter Developer settings page" - this
// https://developer.twitter.com/en/portal/dashboard and chosing of project from list (key icon)
Parameters_ = New Map;
Parameters_ = New Map;
Permissions = "tweet.read tweet.write tweet.moderate.write users.read "
+ "follows.read follows.write offline.access space.read mute.read "
+ "mute.write like.read like.write list.read list.write block.read "
+ "block.write bookmark.read bookmark.write";
+ "block.write bookmark.read bookmark.write";
// Data for API v2
// redirect_uri - URL of your http service (or other request handler) for authorization
// scope - a set of permissions for the received key. Can be any, but offline.access is mandatory
// client_id - From OAuth 2.0 Client ID and Client Secret settings page of Twitter Developer
// client_secret - From OAuth 2.0 Client ID and Client Secret settings page of Twitter Developer
// access_token - GetAuthorizationLink() -> Browser -> code will come to redirect_uri -> GetToken(code)
// refresh_token - Comes together with access_token and is used to refresh it (access_token lifetime - 2 hr)
// The update is done using the UpdateToken method with new access_token and refresh_token.
// For the next update, you need to use a new refresh_token, so hardcode
// won't work (access_token won't work either)
// The update is done using the UpdateToken method with new access_token and refresh_token.
// For the next update, you need to use a new refresh_token, so hardcode
// won't work (access_token won't work either)
// |--> RefreshToken() ->|access_token --> 2 hrs. lifetime
// | |refresh_token --|
// |--------[after 2 hrs.]-------------------|
// Data for API v1.1
// oauth_token - From Authentication Tokens -> Access Token and Secret settings page of Twitter Developer
// oauth_token - From Authentication Tokens -> Access Token and Secret settings page of Twitter Developer
// oauth_token_secret - From Authentication Tokens -> Access Token and Secret settings page of Twitter Developer
// oauth_consumer_key - From Consumer Keys -> Access Token and Secret settings page of Twitter Developer
// oauth_consumer_secret - From Consumer Keys -> Access Token and Secret settings page of Twitter Developer
// These tokens do not need to be updated
Parameters_.Insert("redirect_uri" , "");
Parameters_.Insert("scope" , Permissions);
Parameters_.Insert("client_id" , "");
Parameters_.Insert("client_secret" , "");
Parameters_.Insert("access_token" , ""); // Should be something like Constants.TwitterToken.Get()
Parameters_.Insert("refresh_token" , ""); // Should be something like Constants.TwitterRefresh.Get()
Parameters_.Insert("oauth_token" , "");
Parameters_.Insert("oauth_token_secret" , "");
Parameters_.Insert("oauth_consumer_key" , "");
Parameters_.Insert("redirect_uri" , "");
Parameters_.Insert("scope" , Permissions);
Parameters_.Insert("client_id" , "");
Parameters_.Insert("client_secret" , "");
Parameters_.Insert("access_token" , ""); // Should be something like Constants.TwitterToken.Get()
Parameters_.Insert("refresh_token" , ""); // Should be something like Constants.TwitterRefresh.Get()
Parameters_.Insert("oauth_token" , "");
Parameters_.Insert("oauth_token_secret" , "");
Parameters_.Insert("oauth_consumer_key" , "");
Parameters_.Insert("oauth_consumer_secret", "");
OPI_TypeConversion.GetCollection(Parameters);
If TypeOf(Parameters) = Type("Structure") Or TypeOf(Parameters) = Type("Map") Then
For Each PassedParameter In Parameters Do
Parameters_.Insert(PassedParameter.Key, OPI_Tools.NumberToString(PassedParameter.Value));
@ -551,137 +551,137 @@ Function GetStandardParameters(Val Parameters = "")
EndFunction
Function CreateAuthorizationHeaderV1(Val Parameters, Val Fields, Val RequestType, Val URL)
CurrentDate = OPI_Tools.GetCurrentDate();
CurrentDate = OPI_Tools.GetCurrentDate();
AuthorizationHeader = "";
HashingMethod = "HMAC-SHA1";
APIVersion = "1.0";
SignatureString = "";
Signature = "";
HashingMethod = "HMAC-SHA1";
APIVersion = "1.0";
SignatureString = "";
Signature = "";
OCK = "oauth_consumer_key";
OTK = "oauth_token";
CurrentUNIXDate = OPI_Tools.UNIXTime(CurrentDate);
CurrentUNIXDate = OPI_Tools.NumberToString(CurrentUNIXDate);
ParametersTable = New ValueTable;
CurrentUNIXDate = OPI_Tools.UNIXTime(CurrentDate);
CurrentUNIXDate = OPI_Tools.NumberToString(CurrentUNIXDate);
ParametersTable = New ValueTable;
ParametersTable.Columns.Add("Key");
ParametersTable.Columns.Add("Value");
For Each Field In Fields Do
NewLine = ParametersTable.Add();
NewLine.Key = Field.Key;
For Each Field In Fields Do
NewLine = ParametersTable.Add();
NewLine.Key = Field.Key;
NewLine.Value = Field.Value;
EndDo;
NewLine = ParametersTable.Add();
NewLine.Key = OCK;
NewLine = ParametersTable.Add();
NewLine.Key = OCK;
NewLine.Value = Parameters[OCK];
NewLine = ParametersTable.Add();
NewLine.Key = OTK;
NewLine = ParametersTable.Add();
NewLine.Key = OTK;
NewLine.Value = Parameters[OTK];
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_version";
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_version";
NewLine.Value = APIVersion;
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_signature_method";
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_signature_method";
NewLine.Value = HashingMethod;
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_timestamp";
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_timestamp";
NewLine.Value = CurrentUNIXDate;
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_nonce";
NewLine = ParametersTable.Add();
NewLine.Key = "oauth_nonce";
NewLine.Value = CurrentUNIXDate;
For Each TableRow In ParametersTable Do
TableRow.Key = EncodeString(TableRow.Key, StringEncodingMethod.URLencoding);
TableRow.Key = EncodeString(TableRow.Key, StringEncodingMethod.URLencoding);
TableRow.Value = EncodeString(TableRow.Value, StringEncodingMethod.URLencoding);
EndDo;
ParametersTable.Sort("Key");
For Each TableRow In ParametersTable Do
SignatureString = SignatureString
+ TableRow.Key
+ "="
SignatureString = SignatureString
+ TableRow.Key
+ " ="
+ TableRow.Value
+ "&";
EndDo;
SignatureString = Left(SignatureString, StrLen(SignatureString) - 1);
SignatureString = Upper(RequestType)
+ "&"
+ EncodeString(URL, StringEncodingMethod.URLencoding)
SignatureString = Upper(RequestType)
+ "&"
+ EncodeString(URL , StringEncodingMethod.URLencoding)
+ "&"
+ EncodeString(SignatureString, StringEncodingMethod.URLencoding);
Signature = EncodeString(Parameters["oauth_consumer_secret"], StringEncodingMethod.URLencoding)
+ "&"
+ "&"
+ EncodeString(Parameters["oauth_token_secret"], StringEncodingMethod.URLencoding);
Signature = OPI_Cryptography.HMAC(GetBinaryDataFromString(Signature)
, GetBinaryDataFromString(SignatureString)
, HashFunction.SHA1
, 64);
Signature = EncodeString(Base64String(Signature), StringEncodingMethod.URLencoding);
Delimiter = """,";
AuthorizationHeader = AuthorizationHeader
AuthorizationHeader = AuthorizationHeader
+ "OAuth "
+ "oauth_consumer_key=""" + Parameters[OCK] + Delimiter
+ "oauth_token=""" + Parameters[OTK] + Delimiter
+ "oauth_consumer_key =""" + Parameters[OCK] + Delimiter
+ "oauth_token =""" + Parameters[OTK] + Delimiter
+ "oauth_signature_method=""" + HashingMethod + Delimiter
+ "oauth_timestamp=""" + CurrentUNIXDate + Delimiter
+ "oauth_nonce=""" + CurrentUNIXDate + Delimiter
+ "oauth_version=""" + APIVersion + Delimiter
+ "oauth_signature=""" + Signature;
+ "oauth_timestamp =""" + CurrentUNIXDate + Delimiter
+ "oauth_nonce =""" + CurrentUNIXDate + Delimiter
+ "oauth_version =""" + APIVersion + Delimiter
+ "oauth_signature =""" + Signature;
HeaderMapping = New Map;
HeaderMapping.Insert("authorization", AuthorizationHeader);
Return HeaderMapping;
EndFunction
Function CreateAuthorizationHeaderV2(Val Parameters)
ReturnMapping = New Map;
ReturnMapping.Insert("Authorization", "Bearer " + Parameters["access_token"]);
Return ReturnMapping;
EndFunction
Function GetProcessingStatus(Val Parameters, Val Fields, Val URL)
ProcessingInfo = "processing_info";
ProcessingInfo = "processing_info";
Authorization = CreateAuthorizationHeaderV1(Parameters, Fields, "POST", URL);
Response = OPI_Tools.Post(URL, Fields, Authorization, False);
Response = OPI_Tools.Post(URL, Fields, Authorization, False);
Information = Response[ProcessingInfo];
If Not ValueIsFilled(Information) Then
Return Response;
EndIf;
ProcessingStatus = Information["state"];
If Not ValueIsFilled(ProcessingStatus) Then
Return Response;
Else
Return ProcessingStatus;
EndIf;
EndIf;
EndFunction
#EndRegion

242
src/en/OPI/src/CommonModules/OPI_TypeConversion/Module.bsl
View File

@ -39,268 +39,268 @@
#Region Internal
Procedure GetBinaryData(Value) Export
If Value = Undefined Then
Return;
EndIf;
Try
Try
If TypeOf(Value) = Type("BinaryData") Then
Return;
Else
File = New File(Value);
If File.Exists() Then
Value = New BinaryData(Value);
ElsIf StrFind(Value, "//") Then
Value = OPI_Tools.Get(Value);
Else
Value = Base64Value(Value);
EndIf;
EndIf;
Except
Raise "Error getting binary data from parameter: " + ErrorDescription();
EndTry;
EndProcedure
Procedure GetBinaryOrStream(Value) Export
If Value = Undefined Then
Return;
EndIf;
If TypeOf(Value) <> Type("String") Then
GetBinaryData(Value);
Return;
EndIf;
File = New File(Value);
If File.Exists() Then
Value = New FileStream(Value, FileOpenMode.Open);
Value = New FileStream(Value, FileOpenMode.Open);
Else
GetBinaryData(Value);
EndIf;
EndProcedure
Procedure GetCollection(Value) Export
If Value = Undefined Then
Return;
EndIf;
Try
Try
InitialValue = Value;
If ThisIsCollection(Value) Then
Return;
Else
If TypeOf(Value) = Type("BinaryData") Then
Value = GetStringFromBinaryData(Value);
Value = GetStringFromBinaryData(Value);
Else
Value = OPI_Tools.NumberToString(Value);
Value = OPI_Tools.NumberToString(Value);
EndIf;
File = New File(Value);
File = New File(Value);
JSONReader = New JSONReader;
If File.Exists() Then
JSONReader.OpenFile(Value);
ElsIf StrStartsWith(Lower(Value), "http") Then
TFN = GetTempFileName();
FileCopy(Value, TFN);
JSONReader.OpenFile(TFN);
JSONReader.Read();
DeleteFiles(TFN);
Else
JSONReader.SetString(TrimAll(Value));
EndIf;
Value = ReadJSON(JSONReader, True, Undefined, JSONDateFormat.ISO);
JSONReader.Close();
If (Not ThisIsCollection(Value)) Or Not ValueIsFilled(Value) Then
Value = InitialValue;
GetArray(Value);
EndIf;
EndIf;
Except
Value = InitialValue;
GetArray(Value);
GetArray(Value);
EndTry;
EndProcedure
Procedure GetArray(Value) Export
If TypeOf(Value) = Type("Array") Then
Return;
EndIf;
If TypeOf(Value) = Type("String")
If TypeOf(Value) = Type("String")
And StrStartsWith(Value, "[")
And StrEndsWith(Value, "]") Then
CommaInQuotes = "','";
Value = StrReplace(Value, "['" , "");
Value = StrReplace(Value, "']" , "");
Value = StrReplace(Value, "['" , "");
Value = StrReplace(Value, "']" , "");
Value = StrReplace(Value, "', '" , CommaInQuotes);
Value = StrReplace(Value, "' , '", CommaInQuotes);
Value = StrReplace(Value, "' ,'" , CommaInQuotes);
Value = StrSplit(Value, CommaInQuotes, False);
For N = 0 To Value.UBound() Do
For N = 0 To Value.UBound() Do
Value[N] = TrimAll(Value[N]);
EndDo;
Else
If TypeOf(Value) = Type("Number") Then
Value = OPI_Tools.NumberToString(Value);
Value = OPI_Tools.NumberToString(Value);
EndIf;
OPI_Tools.ValueToArray(Value);
EndIf;
EndProcedure
Procedure GetBoolean(Value) Export
If Value = Undefined Then
Return;
EndIf;
Try
Try
If TypeOf(Value) = Type("Boolean") Then
Return;
Else
Value = Boolean(Value);
Value = Boolean(Value);
EndIf;
Except
Raise "Error getting boolean data from parameter";
EndTry;
EndProcedure
Procedure GetLine(Value, Val FromSource = False) Export
If Value = Undefined Then
Return;
EndIf;
Try
Try
If ThisIsSymbolic(Value) Then
If Not FromSource Then
Value = OPI_Tools.NumberToString(Value);
Return;
Return;
EndIf;
Value = OPI_Tools.NumberToString(Value);
File = New File(Value);
Value = OPI_Tools.NumberToString(Value);
File = New File(Value);
If File.Exists() Then
TextReader = New TextReader(Value);
Value = TextReader.Read();
Value = TextReader.Read();
TextReader.Close();
ElsIf StrStartsWith(Lower(Value), "http") Then
TFN = GetTempFileName();
FileCopy(Value, TFN);
TextReader = New TextReader(TFN);
Value = TextReader.Read();
Value = TextReader.Read();
TextReader.Close();
DeleteFiles(TFN);
Else
Return;
EndIf;
ElsIf TypeOf(Value) = Type("BinaryData") Then
Value = GetStringFromBinaryData(Value);
ElsIf ThisIsCollection(Value) Then
Value = OPI_Tools.JSONString(Value);
Value = OPI_Tools.JSONString(Value);
Else
Return;
EndIf;
Except
Value = String(Value);
Return;
EndTry;
EndProcedure
Procedure GetDate(Value) Export
If Value = Undefined Then
Return;
EndIf;
Date = "Date";
Try
Try
If TypeOf(Value) = Type(Date) Then
Return;
Else
Value = XMLValue(Type(Date), Value);
Else
Value = XMLValue(Type(Date), Value);
EndIf;
Except
OOD = New TypeDescription(Date);
OOD = New TypeDescription(Date);
Value = OOD.AdjustValue(Value);
EndTry;
EndProcedure
Procedure GetNumber(Value) Export
TypeDescription = New TypeDescription("Number");
Value = TypeDescription.AdjustValue(Value);
Value = TypeDescription.AdjustValue(Value);
EndProcedure
#EndRegion
@ -308,19 +308,19 @@ EndProcedure
#Region Private
Function ThisIsCollection(Val Value)
Return TypeOf(Value) = Type("Array")
Return TypeOf(Value) = Type("Array")
Or TypeOf(Value) = Type("Structure")
Or TypeOf(Value) = Type("Map");
EndFunction
EndFunction
Function ThisIsSymbolic(Val Value)
Return TypeOf(Value) = Type("String")
Or TypeOf(Value) = Type("Number")
Return TypeOf(Value) = Type("String")
Or TypeOf(Value) = Type("Number")
Or TypeOf(Value) = Type("Date");
EndFunction
EndFunction
#EndRegion

1578
src/en/OPI/src/CommonModules/OPI_VK/Module.bsl
View File

File diff suppressed because it is too large Load Diff

234
src/en/OPI/src/CommonModules/OPI_Viber/Module.bsl
View File

@ -23,7 +23,7 @@
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
// https://github.com/Bayselonarrend/OpenIntegrations
// BSLLS:LatinAndCyrillicSymbolInWord-off
@ -46,55 +46,55 @@
// which will return 200 and a genuine SSL certificate. If there is a certificate and the database is published
// on the server - you can use an HTTP service. Information about new messages will also be sent there
// Viber periodically knocks on the Webhook address, so if it is inactive, everything will stop working
//
//
// Parameters:
// Token - String - Viber Token - token
// URL - String - URL for setting up Webhook - url
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SetWebhook(Val Token, Val URL) Export
Parameters = New Structure;
OPI_Tools.AddField("url" , URL , "String", Parameters);
OPI_Tools.AddField("url" , URL , "String", Parameters);
OPI_Tools.AddField("auth_token" , Token, "String", Parameters);
Return OPI_Tools.Post("https://chatapi.viber.com/pa/set_webhook", Parameters);
EndFunction
// Get channel information
// Here you can get the channel's user IDs. Bot IDs need to be obtained from the Webhook arrivals
// The user ID from channel information is not suitable for sending messages through the bot - they are different
//
//
// Parameters:
// Token - String - Token - token
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function GetChannelInformation(Val Token) Export
URL = "https://chatapi.viber.com/pa/get_account_info";
URL = "https://chatapi.viber.com/pa/get_account_info";
Return OPI_Tools.Get(URL, , TokenInHeaders(Token));
EndFunction
// Get user data
// Gets user information by ID
//
//
// Parameters:
// Token - String - Token - token
// UserID - String, Number - Viber User ID - user
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function GetUserData(Val Token, Val UserID) Export
URL = "https://chatapi.viber.com/pa/get_user_details";
Parameters = New Structure;
OPI_Tools.AddField("id", UserID, "String", Parameters);
Response = OPI_Tools.Post(URL, Parameters, TokenInHeaders(Token));
Return Response;
@ -103,22 +103,22 @@ EndFunction
// Get online users
// Gets the status of a user or multiple users by ID
//
//
// Parameters:
// Token - String - Viber Token - token
// UserIDs - String,Number,Array of String,Number - Viber User(s) ID - users
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function GetOnlineUsers(Val Token, Val UserIDs) Export
URL = "https://chatapi.viber.com/pa/get_online";
Parameters = New Structure;
OPI_Tools.AddField("ids", UserIDs, "Collection", Parameters);
Response = OPI_Tools.Post(URL, Parameters, TokenInHeaders(Token));
Return Response;
EndFunction
@ -129,14 +129,14 @@ EndFunction
// Send text message
// Sends a text message to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// Text - String - Message text - text
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - Boolean - Sending to channel or bot chat - ischannel
// Keyboard - Structure Of String - See CreateKeyboardFromArrayButton - keyboard
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendTextMessage(Val Token
@ -144,40 +144,40 @@ Function SendTextMessage(Val Token
, Val UserID
, Val SendingToChannel
, Val Keyboard = "") Export
Return SendMessage(Token, "text", UserID, SendingToChannel, , Text, Keyboard);
Return SendMessage(Token, "text", UserID, SendingToChannel, , Text, Keyboard);
EndFunction
// Send image
// Sends an image to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// URL - String - Image URL - picture
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - boolean - Sending to channel or bot chat - ischannel
// Description - String - Image annotation - description
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendImage(Val Token, Val URL, Val UserID, Val SendingToChannel, Val Description = "") Export
Return SendMessage(Token, "picture", UserID, SendingToChannel, URL, Description);
EndFunction
// SendFile
// Sends a file (document) to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// URL - String - File URL - file
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// URL - String - File URL - file
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - Boolean - Sending to channel or bot chat - ischannel
// Extension - String - File extension - ext
// Size - Number - File size. If not filled in > determined automatically by downloading the file - size
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendFile(Val Token
@ -186,36 +186,36 @@ Function SendFile(Val Token
, Val SendingToChannel
, Val Extension
, Val Size = "") Export
If Not ValueIsFilled(Size) Then
Response = OPI_Tools.Get(URL);
Size = Response.Size();
Size = Response.Size();
EndIf;
String_ = "String";
String_ = "String";
Extension = StrReplace(Extension, ".", "");
Parameters = New Structure;
OPI_Tools.AddField("URL" , URL , String_, Parameters);
OPI_Tools.AddField("Size" , Size , String_, Parameters);
OPI_Tools.AddField("URL" , URL , String_, Parameters);
OPI_Tools.AddField("Size" , Size , String_, Parameters);
OPI_Tools.AddField("Extension", Extension, String_, Parameters);
Return SendMessage(Token, "file", UserID, SendingToChannel, Parameters);
EndFunction
// Send contact
// Sends a contact with a phone number to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// ContactName - String - Contact name - name
// PhoneNumber - String - Phone number - phone
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - Boolean - Sending to channel or bot chat - ischannel
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendContact(Val Token
@ -223,91 +223,91 @@ Function SendContact(Val Token
, Val PhoneNumber
, Val UserID
, Val SendingToChannel) Export
Parameters = New Structure;
OPI_Tools.AddField("name" , ContactName , "String", Parameters);
OPI_Tools.AddField("phone_number", PhoneNumber, "String", Parameters);
Return SendMessage(Token, "contact", UserID, SendingToChannel, Parameters);
OPI_Tools.AddField("name" , ContactName , "String", Parameters);
OPI_Tools.AddField("phone_number", PhoneNumber , "String", Parameters);
Return SendMessage(Token, "contact", UserID, SendingToChannel, Parameters);
EndFunction
// Send location
// Sends geographic coordinates to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// Latitude - String, Number - Geographic latitude - lat
// Longitude - String, Number - Geographic longitude - long
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - Boolean - Sending to channel or bot chat - ischannel
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendLocation(Val Token, Val Latitude, Val Longitude, Val UserID, Val SendingToChannel) Export
Parameters = New Structure;
OPI_Tools.AddField("lat", Latitude , "String", Parameters);
OPI_Tools.AddField("lon", Longitude, "String", Parameters);
Return SendMessage(Token, "location", UserID, SendingToChannel, Parameters);
EndFunction
// Send link
// Sends a URL with a preview to a chat or channel
//
//
// Parameters:
// Token - String - Token - token
// URL - String - SentLink - url
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// UserID - String, Number - User ID. For channel > administrator, for bot > recipient - user
// SendingToChannel - Boolean - Sending to channel or bot chat - ischannel
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Viber
Function SendLink(Val Token, Val URL, Val UserID, Val SendingToChannel) Export
Return SendMessage(Token, "url", UserID, SendingToChannel, URL);
EndFunction
// Create a keyboard from an array of buttons
// Returns a keyboard structure for messages
//
//
// Parameters:
// ButtonArray - Array of String - Array of buttons - buttons
// ButtonColor - String - HEX color of buttons with # at the beginning - color
//
//
// Returns:
// Structure - Create a keyboard from an array of buttons:
// * Buttons - Array of Structure - Array of formed buttons
// * Type - String - KeyboardType
// * Buttons - Array of Structure - Array of formed buttons
// * Type - String - KeyboardType
Function CreateKeyboardFromArrayButton(Val ButtonArray, Val ButtonColor = "#2db9b9") Export
OPI_TypeConversion.GetLine(ButtonColor);
OPI_TypeConversion.GetCollection(ButtonArray);
ArrayOfButtonStructures = New Array;
KeyboardStructure = New Structure;
KeyboardStructure = New Structure;
For Each ButtonText In ButtonArray Do
ButtonStructure = New Structure;
ButtonStructure.Insert("ActionType", "reply");
ButtonStructure.Insert("ActionBody", ButtonText);
ButtonStructure.Insert("Text" , ButtonText);
ButtonStructure.Insert("BgColor" , ButtonColor);
ButtonStructure.Insert("Coloumns" , 3);
ButtonStructure.Insert("Text" , ButtonText);
ButtonStructure.Insert("BgColor" , ButtonColor);
ButtonStructure.Insert("Coloumns" , 3);
ArrayOfButtonStructures.Add(ButtonStructure);
EndDo;
KeyboardStructure.Insert("Buttons", ArrayOfButtonStructures);
KeyboardStructure.Insert("Type" , "keyboard");
KeyboardStructure.Insert("Type" , "keyboard");
Return KeyboardStructure;
EndFunction
#EndRegion
@ -317,7 +317,7 @@ EndFunction
#Region Private
// Send message.
//
//
// Parameters:
// Token - String - Token
// Type - String - TypeOfSentMessage
@ -328,8 +328,8 @@ EndFunction
// * Size - Number, String - File size in case of sending
// * Extension - String - File extension in case of sending
// Text - String - Message text
// Keyboard - Structure Of String - Keyboard, if needed, see CreateKeyboardFromArrayButton
//
// Keyboard - Structure Of String - Keyboard, if needed, see CreateKeyboardFromArrayButton
//
// Returns:
// Arbitrary, HTTPResponse - Send message
Function SendMessage(Val Token
@ -339,81 +339,81 @@ Function SendMessage(Val Token
, Val Value = ""
, Val Text = ""
, Val Keyboard = "")
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Type);
OPI_TypeConversion.GetLine(UserID);
OPI_TypeConversion.GetLine(Text);
OPI_TypeConversion.GetBoolean(IsChannel);
OPI_TypeConversion.GetCollection(Keyboard);
ParametersStructure = ReturnStandardParameters();
ParametersStructure.Insert("type", Type);
ParametersStructure.Insert("type", Type);
If (Type = "text" Or Type = "picture") And ValueIsFilled(Text) Then
ParametersStructure.Insert("text", Text);
EndIf;
If TypeOf(Keyboard) = Type("Structure") Then
ParametersStructure.Insert("keyboard", Keyboard);
EndIf;
If ValueIsFilled(Value) Then
If Type = "file" Then
ParametersStructure.Insert("media" , Value["URL"]);
ParametersStructure.Insert("size" , Value["Size"]);
If Type = "file" Then
ParametersStructure.Insert("media" , Value["URL"]);
ParametersStructure.Insert("size" , Value["Size"]);
ParametersStructure.Insert("file_name", "File." + Value["Extension"]);
ElsIf Type = "contact" Then
ParametersStructure.Insert("contact" , Value);
ParametersStructure.Insert("contact" , Value);
ElsIf Type = "location" Then
ParametersStructure.Insert("location" , Value);
Else
ParametersStructure.Insert("media" , Value);
ParametersStructure.Insert("media" , Value);
EndIf;
EndIf;
If IsChannel Then
ParametersStructure.Insert("from", UserID);
ParametersStructure.Insert("from" , UserID);
URL = "https://chatapi.viber.com/pa/post";
Else
Else
ParametersStructure.Insert("receiver", UserID);
URL = "https://chatapi.viber.com/pa/send_message";
EndIf;
Response = OPI_Tools.Post(URL, ParametersStructure, TokenInHeaders(Token));
Try
Return OPI_Tools.JsonToStructure(Response.GetBodyAsBinaryData());
Except
Return Response;
EndTry;
EndFunction
Function ReturnStandardParameters()
Function ReturnStandardParameters()
SenderStructure = New Structure;
SenderStructure.Insert("name" , "Bot");
SenderStructure.Insert("name" , "Bot");
SenderStructure.Insert("avatar", "");
ParametersStructure = New Structure;
ParametersStructure.Insert("sender", SenderStructure);
ParametersStructure.Insert("sender" , SenderStructure);
ParametersStructure.Insert("min_api_version", 1);
Return ParametersStructure;
EndFunction
Function TokenInHeaders(Val Token)
OPI_TypeConversion.GetLine(Token);
HeadersStructure = New Map;
HeadersStructure.Insert("X-Viber-Auth-Token", Token);
Return HeadersStructure;
EndFunction
#EndRegion

432
src/en/OPI/src/CommonModules/OPI_YandexDisk/Module.bsl
View File

@ -37,7 +37,7 @@
//@skip-check wrong-string-literal-content
// Uncomment if OneScript is executed
// #Use "../../tools"
// #Use "../../tools"
#Region Public
@ -45,217 +45,217 @@
// Get disk information
// Gets information about the current disk
//
//
// Parameters:
// Token - String - Token - token
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetDiskInformation(Val Token) Export
OPI_TypeConversion.GetLine(Token);
Headers = AuthorizationHeader(Token);
Headers = AuthorizationHeader(Token);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk", , Headers);
Return Response;
EndFunction
// Create folder
// Creates a directory on the disk
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the created folder - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function CreateFolder(Val Token, Val Path) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
Headers = AuthorizationHeader(Token);
URL = "https://cloud-api.yandex.net/v1/disk/resources";
Href = "href";
URL = "https://cloud-api.yandex.net/v1/disk/resources";
Href = "href";
Parameters = New Structure;
Parameters.Insert("path", Path);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Put(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Put(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
If Not ValueIsFilled(ResponseURL) Then
Return Response;
Return Response;
EndIf;
Response = OPI_Tools.Get(ResponseURL, , Headers);
Return Response;
EndFunction
// Get object
// Gets information about a disk object at the specified path
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to folder or file - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetObject(Val Token, Val Path) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
Headers = AuthorizationHeader(Token);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
Parameters.Insert("path", Path);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/resources", Parameters, Headers);
Return Response;
EndFunction
// Delete object
// Deletes an object at the specified path
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the folder or file to be deleted - path
// ToCart - Boolean - To cart - can
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function DeleteObject(Val Token, Val Path, Val ToCart = True) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetBoolean(ToCart);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
Parameters.Insert("path" , Path);
Parameters.Insert("path" , Path);
Parameters.Insert("permanently", Not ToCart);
Response = OPI_Tools.Delete("https://cloud-api.yandex.net/v1/disk/resources", Parameters, Headers);
Return Response;
EndFunction
// Create object copy
// Creates a copy of the object at the specified path and path to the original
//
//
// Parameters:
// Token - String - Token - token
// Original - String - Path to the original file or directory - from
// Path - String - Destination path for the copy - to
// Overwrite - Boolean - Overwrite if a file with the same name already exists - rewrite
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function CreateObjectCopy(Val Token, Val Original, Val Path, Val Overwrite = False) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Original);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetBoolean(Overwrite);
Headers = AuthorizationHeader(Token);
URL = "https://cloud-api.yandex.net/v1/disk/resources/copy";
Href = "href";
URL = "https://cloud-api.yandex.net/v1/disk/resources/copy";
Href = "href";
Parameters = New Structure;
Parameters.Insert("from" , Original);
Parameters.Insert("path" , Path);
Parameters.Insert("from" , Original);
Parameters.Insert("path" , Path);
Parameters.Insert("overwrite" , Overwrite);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
If Not ValueIsFilled(ResponseURL) Then
Return Response;
Return Response;
EndIf;
Response = OPI_Tools.Get(ResponseURL, , Headers);
Return Response;
EndFunction
// Get download link
// Gets a download link for the file
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the file for downloading - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetDownloadLink(Val Token, Val Path) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
Parameters.Insert("path", Path);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/resources/download", Parameters, Headers);
Return Response;
EndFunction
// Download file
// Downloads a file at the specified path
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the file for downloading - path
// SavePath - String - File save path - out
//
// SavePath - String - File save path - out
//
// Returns:
// BinaryData,String - Binary data or file path when SavePath parameter is specified
Function DownloadFile(Val Token, Val Path, Val SavePath = "") Export
OPI_TypeConversion.GetLine(SavePath);
Response = GetDownloadLink(Token, Path);
URL = Response["href"];
URL = Response["href"];
If Not ValueIsFilled(URL) Then
Return Response;
EndIf;
Response = OPI_Tools.Get(URL, , , SavePath);
Return Response;
EndFunction
// Get list of files
// Gets a list of files with or without filtering by type
// List of available types: audio, backup, book, compressed, data, development,
// diskimage, document, encoded, executable, flash, font,
// List of available types: audio, backup, book, compressed, data, development,
// diskimage, document, encoded, executable, flash, font,
// mage, settings, spreadsheet, text, unknown, video, web
//
//
// Parameters:
// Token - String - Token - token
// Count - Number, String - Number of returned objects - amount
// OffsetFromStart - Number - Offset for getting objects not from the beginning of the list - offset
// FilterByType - String - Filter by file type - type
// SortByDate - Boolean - True > sort by date, False > alphabetically - datesort
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetFilesList(Val Token
@ -263,50 +263,50 @@ Function GetFilesList(Val Token
, Val OffsetFromStart = 0
, Val FilterByType = ""
, Val SortByDate = False) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Count);
OPI_TypeConversion.GetLine(OffsetFromStart);
OPI_TypeConversion.GetLine(FilterByType);
OPI_TypeConversion.GetBoolean(SortByDate);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
If ValueIsFilled(Count) Then
Parameters.Insert("limit", OPI_Tools.NumberToString(Count));
EndIf;
If ValueIsFilled(OffsetFromStart) Then
Parameters.Insert("offset", OPI_Tools.NumberToString(OffsetFromStart));
EndIf;
If ValueIsFilled(FilterByType) Then
Parameters.Insert("media_type", FilterByType);
EndIf;
If SortByDate Then
Destination = "last-uploaded";
Else
Destination = "files";
EndIf;
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/resources/" + Destination, Parameters, Headers);
Return Response;
EndFunction
// Move object
// Moves the object to the specified path and path to the original
//
//
// Parameters:
// Token - String - Token - token
// Original - String - Path to the original file or folder - from
// Path - String - Destination path for moving - to
// Overwrite - Boolean - Overwrite if a file with the same name already exists - rewrite
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function MoveObject(Val Token, Val Original, Val Path, Val Overwrite = False) Export
@ -315,97 +315,97 @@ Function MoveObject(Val Token, Val Original, Val Path, Val Overwrite = False) Ex
OPI_TypeConversion.GetLine(Original);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetBoolean(Overwrite);
Headers = AuthorizationHeader(Token);
URL = "https://cloud-api.yandex.net/v1/disk/resources/move";
Href = "href";
URL = "https://cloud-api.yandex.net/v1/disk/resources/move";
Href = "href";
Parameters = New Structure;
Parameters.Insert("from" , Original);
Parameters.Insert("path" , Path);
Parameters.Insert("from" , Original);
Parameters.Insert("path" , Path);
Parameters.Insert("overwrite" , Overwrite);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
If Not ValueIsFilled(ResponseURL) Then
Return Response;
Return Response;
EndIf;
Response = OPI_Tools.Get(ResponseURL, , Headers);
Return Response;
EndFunction
// Upload file
// Uploads a file to disk at the specified path
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path for saving the file to disk - path
// File - String, BinaryData - File for upload - file
// Overwrite - Boolean - Overwrite if a file with the same name already exists - rewrite
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
// Map Of KeyAndValue - serialized JSON response from Yandex
Function UploadFile(Val Token, Val Path, Val File, Val Overwrite = False) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetBoolean(Overwrite);
OPI_TypeConversion.GetBinaryData(File);
Headers = AuthorizationHeader(Token);
Href = "href";
File = New Structure("file", File);
Href = "href";
File = New Structure("file", File);
Parameters = New Structure;
Parameters.Insert("path" , Path);
Parameters.Insert("path" , Path);
Parameters.Insert("overwrite" , Overwrite);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/resources/upload", Parameters, Headers);
URL = Response[Href];
URL = Response[Href];
If Not ValueIsFilled(URL) Then
Return Response;
Return Response;
EndIf;
Response = OPI_Tools.PutMultipart(URL, New Structure(), File, "multipart", Headers);
Return Response;
EndFunction
// Upload file by URL
// Downloads a file to disk from the specified URL
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to place the downloaded file - path
// Address - String - File URL - url
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function UploadFileByURL(Val Token, Val Path, Val Address) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetLine(Address);
Headers = AuthorizationHeader(Token);
URL = "https://cloud-api.yandex.net/v1/disk/resources/upload";
URL = "https://cloud-api.yandex.net/v1/disk/resources/upload";
Parameters = New Structure;
Parameters.Insert("url" , EncodeString(Address, StringEncodingMethod.URLencoding));
Parameters.Insert("path", Path);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(URL + Parameters, , Headers, False);
Return Response;
EndFunction
#EndRegion
@ -414,186 +414,186 @@ EndFunction
// Publish object
// Publishes the disk object for public access
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the object to be published - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
// Map Of KeyAndValue - serialized JSON response from Yandex
Function PublishObject(Val Token, Val Path) Export
Return TogglePublicAccess(Token, Path, True);
Return TogglePublicAccess(Token, Path, True);
EndFunction
// Unpublish object
// Unpublishes a previously published object
//
//
// Parameters:
// Token - String - Token - token
// Path - String - Path to the previously published object - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function CancelObjectPublication(Val Token, Val Path) Export
Return TogglePublicAccess(Token, Path, False);
EndFunction
// Get list of published objects.
// Gets a list of published objects
//
//
// Parameters:
// Token - String - Token - token
// Token - String - Token - token
// Count - Number - Number of returned objects - amount
// OffsetFromStart - Number - Offset for getting objects not from the beginning of the list - offset
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetPublishedObjectsList(Val Token, Val Count = 0, Val OffsetFromStart = 0) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Count);
OPI_TypeConversion.GetLine(OffsetFromStart);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
If ValueIsFilled(Count) Then
Parameters.Insert("limit", Count);
EndIf;
If ValueIsFilled(OffsetFromStart) Then
Parameters.Insert("offset", OffsetFromStart);
EndIf;
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/resources/public", Parameters, Headers);
Return Response;
EndFunction
// Get public object
// Gets information about the published object by its URL
//
//
// Parameters:
// Token - String - Token - token
// URL - String - Object address - url
// URL - String - Object address - url
// Count - Number - Number of returned nested objects (for catalog) - amount
// OffsetFromStart - Number - Offset for getting nested objects not from the beginning of the list - offset
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetPublicObject(Val Token, Val URL, Val Count = 0, Val OffsetFromStart = 0) Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(URL);
OPI_TypeConversion.GetLine(Count);
OPI_TypeConversion.GetLine(OffsetFromStart);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
If ValueIsFilled(Count) Then
Parameters.Insert("limit", OPI_Tools.NumberToString(Count));
EndIf;
If ValueIsFilled(OffsetFromStart) Then
Parameters.Insert("offset", OPI_Tools.NumberToString(OffsetFromStart));
EndIf;
Parameters.Insert("public_key", URL);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/public/resources", Parameters, Headers);
Return Response;
EndFunction
// Get download link for public object
// Gets a direct link to download the public object
//
//
// Parameters:
// Token - String - Token - token
// URL - String - Object address - url
// Path - String - Path inside the object - path
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetDownloadLinkForPublicObject(Val Token, Val URL, Val Path = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(URL);
OPI_TypeConversion.GetLine(Path);
Headers = AuthorizationHeader(Token);
Parameters = New Structure;
If ValueIsFilled(Path) Then
Parameters.Insert("path", Path);
EndIf;
Parameters.Insert("public_key", URL);
Response = OPI_Tools.Get("https://cloud-api.yandex.net/v1/disk/public/resources/download", Parameters, Headers);
Return Response;
Return Response;
EndFunction
// Save public object to disk
// Saves the public object to your disk
//
//
// Parameters:
// Token - String - Token - token
// URL - String - Object address - url
// From - String - Path within public catalog (folders only) - from
// Target - String - File save path - to
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function SavePublicObjectToDisk(Val Token, Val URL, From = "", Target = "") Export
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(URL);
OPI_TypeConversion.GetLine(From);
OPI_TypeConversion.GetLine(Target);
Headers = AuthorizationHeader(Token);
Address = "https://cloud-api.yandex.net/v1/disk/public/resources/save-to-disk";
Href = "href";
Href = "href";
Parameters = New Structure;
Parameters.Insert("public_key", EncodeString(URL, StringEncodingMethod.URLencoding));
If ValueIsFilled(From) Then
Parameters.Insert("path", From);
EndIf;
If ValueIsFilled(Target) Then
Parameters.Insert("save_path", Target);
EndIf;
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(Address + Parameters, , Headers, False);
ResponseURL = Response[Href];
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Post(Address + Parameters, , Headers, False);
ResponseURL = Response[Href];
If Not ValueIsFilled(ResponseURL) Then
Return Response;
Return Response;
EndIf;
Response = OPI_Tools.Get(ResponseURL, , Headers);
Return Response;
EndFunction
#EndRegion
#EndRegion
@ -601,42 +601,42 @@ EndFunction
#Region Private
Function AuthorizationHeader(Val Token)
Headers = New Map;
Headers.Insert("Authorization", "OAuth " + Token);
Return Headers;
EndFunction
Function TogglePublicAccess(Val Token, Val Path, Val PublicAccess)
Function TogglePublicAccess(Val Token, Val Path, Val PublicAccess)
OPI_TypeConversion.GetLine(Token);
OPI_TypeConversion.GetLine(Path);
OPI_TypeConversion.GetBoolean(PublicAccess);
Headers = AuthorizationHeader(Token);
Headers = AuthorizationHeader(Token);
Destination = ?(PublicAccess, "publish", "unpublish");
Href = "href";
Href = "href";
URL = "https://cloud-api.yandex.net/v1/disk/resources/" + Destination;
Parameters = New Structure;
Parameters.Insert("path", Path);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Put(URL + Parameters, , Headers, False);
Parameters = OPI_Tools.RequestParametersToString(Parameters);
Response = OPI_Tools.Put(URL + Parameters, , Headers, False);
ResponseURL = Response[Href];
If Not ValueIsFilled(ResponseURL) Then
Return Response;
EndIf;
Return Response;
EndIf;
Response = OPI_Tools.Get(ResponseURL, , Headers);
Return Response;
EndFunction
#EndRegion

50
src/en/OPI/src/CommonModules/OPI_YandexID/Module.bsl
View File

@ -41,77 +41,77 @@
// Get confirmation code
// Gets the confirmation code and the address of the page where it needs to be entered
//
//
// Parameters:
// ClientId - String - Client id - id
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function GetConfirmationCode(Val ClientId) Export
OPI_TypeConversion.GetLine(ClientId);
Parameters = New Structure("client_id", ClientId);
Response = OPI_Tools.Post("https://oauth.yandex.ru/device/code", Parameters, , False);
Response = OPI_Tools.Post("https://oauth.yandex.ru/device/code", Parameters, , False);
Return Response;
EndFunction
// Convert code to token
// Converts the code to a token after entering the code when executing GetConfirmationCode
//
//
// Parameters:
// ClientId - String - Client id - id
// ClientSecret - String - Client secret - secret
// DeviceCode - String - device_code from GetConfirmationCode() - device
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function ConvertCodeToToken(Val ClientId, Val ClientSecret, Val DeviceCode) Export
OPI_TypeConversion.GetLine(ClientId);
OPI_TypeConversion.GetLine(ClientSecret);
OPI_TypeConversion.GetLine(DeviceCode);
Parameters = New Structure;
Parameters.Insert("grant_type" , "device_code");
Parameters.Insert("code" , DeviceCode);
Parameters.Insert("client_id" , ClientId);
Parameters.Insert("grant_type" , "device_code");
Parameters.Insert("code" , DeviceCode);
Parameters.Insert("client_id" , ClientId);
Parameters.Insert("client_secret" , ClientSecret);
Response = OPI_Tools.Post("https://oauth.yandex.ru/token", Parameters, , False);
Return Response;
EndFunction
// Refresh token
// Updates token by Refresh token
//
//
// Parameters:
// ClientId - String - Client id - id
// ClientSecret - String - Client secret - secret
// RefreshToken - String - Refresh token - refresh
//
//
// Returns:
// Map Of KeyAndValue - serialized JSON response from Yandex
Function RefreshToken(Val ClientId, Val ClientSecret, Val RefreshToken) Export
OPI_TypeConversion.GetLine(ClientId);
OPI_TypeConversion.GetLine(ClientSecret);
OPI_TypeConversion.GetLine(RefreshToken);
Parameters = New Structure;
Parameters.Insert("grant_type" , "refresh_token");
Parameters.Insert("grant_type" , "refresh_token");
Parameters.Insert("refresh_token" , RefreshToken);
Parameters.Insert("client_id" , ClientId);
Parameters.Insert("client_id" , ClientId);
Parameters.Insert("client_secret" , ClientSecret);
Response = OPI_Tools.Post("https://oauth.yandex.ru/token", Parameters, , False);
Return Response;
EndFunction
#EndRegion

372
src/ru/OInt/core/Modules/OPI_Airtable.os
View File

@ -42,91 +42,91 @@
// Получить список баз
// Получает список доступных баз
//
//
// Параметры:
// Токен - Строка - Токен - token
// Отступ - Строка - Идентификатор следующей страницы списка баз из перыдудщего запроса - offset
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ПолучитьСписокБаз(Знач Токен, Знач Отступ = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Отступ);
URL = "https://api.airtable.com/v0/meta/bases";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("offset", Отступ, "Строка", Параметры);
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить таблицы базы
// Получает схему таблиц базы
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы - base
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ПолучитьТаблицыБазы(Знач Токен, Знач База) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
URL = "https://api.airtable.com/v0/meta/bases/" + База + "/tables";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Создать базу
// Создает новую базу данных
//
//
// Параметры:
// Токен - Строка - Токен - token
// РабочееПространство - Строка - Идентификатор рабочего пространства - ws
// Наименование - Строка - Наименование новой базы - title
// КоллекцияТаблиц - Соответствие Из КлючИЗначение - Описание таблиц: Ключ > имя, Значение > массив полей - tablesdata
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция СоздатьБазу(Знач Токен, Знач РабочееПространство, Знач Наименование, Знач КоллекцияТаблиц) Экспорт
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(КоллекцияТаблиц);
Если Не ТипЗнч(КоллекцияТаблиц) = Тип("Структура")
Если Не ТипЗнч(КоллекцияТаблиц) = Тип("Структура")
И Не ТипЗнч(КоллекцияТаблиц) = Тип("Соответствие") Тогда
ВызватьИсключение "Ошибка в данных коллекции таблиц";
КонецЕсли;
URL = "https://api.airtable.com/v0/meta/bases";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
МассивТаблиц = Новый Массив;
Для Каждого Таблица Из КоллекцияТаблиц Цикл
Описание = СформироватьОписаниеТаблицы(Таблица.Ключ, Таблица.Значение);
МассивТаблиц.Добавить(Описание);
КонецЦикла;
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("name" , Наименование , "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("tables" , МассивТаблиц , "Массив", Параметры);
OPI_Инструменты.ДобавитьПоле("workspaceId", РабочееПространство, "Строка", Параметры);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
@ -137,56 +137,56 @@
// Создать таблицу
// Создает новую таблицу в базе
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы - base
// Наименование - Строка - Наименование новой таблицы - title
// МассивПолей - Массив Из Структура - Массив описаний полей - fieldsdata
// Описание - Строка - Описание таблицы - description
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция СоздатьТаблицу(Знач Токен, Знач База, Знач Наименование, Знач МассивПолей, Знач Описание = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
URL = "https://api.airtable.com/v0/meta/bases/" + База + "/tables";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = СформироватьОписаниеТаблицы(Наименование, МассивПолей, Описание);
Параметры = СформироватьОписаниеТаблицы(Наименование, МассивПолей, Описание);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Изменить таблицу
// Изменяет наименование и|или описание базы
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы - base
// Таблица - Строка - Идентификатор таблицы - table
// Наименование - Строка - Новое наименование - title
// Описание - Строка - Новое описание - description
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ИзменитьТаблицу(Знач Токен, Знач База, Знач Таблица, Знач Наименование = "", Знач Описание = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
URL = "https://api.airtable.com/v0/meta/bases/" + База + "/tables/" + Таблица;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("name" , Наименование, "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("description", Описание , "Строка", Параметры);
Ответ = OPI_Инструменты.Patch(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
@ -197,40 +197,40 @@
// Создать поле
// Создет новое поле в таблице
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы - base
// Таблица - Строка - Идентификатор таблицы - table
// СтруктураПоля - Структура Из КлючИЗначение - Описание нового поля - fielddata
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция СоздатьПоле(Знач Токен, Знач База, Знач Таблица, Знач СтруктураПоля) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(СтруктураПоля);
Если Не ТипЗнч(СтруктураПоля) = Тип("Структура")
Если Не ТипЗнч(СтруктураПоля) = Тип("Структура")
И Не ТипЗнч(СтруктураПоля) = Тип("Соответствие") Тогда
ВызватьИсключение "Ошибка в данных описания поля";
КонецЕсли;
URL = "https://api.airtable.com/v0/meta/bases/" + База + "/tables/" + Таблица + "/fields";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Post(URL, СтруктураПоля, Заголовки);
Возврат Ответ;
КонецФункции
// Изменить поле
// Изменяет имя и|или описание существующего поля таблицы
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы База - base
@ -238,152 +238,152 @@
// Поле - Строка - Идентификатор поля - field
// Наименование - Строка - Новое наименование - title
// Описание - Строка - Новое описание - description
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ИзменитьПоле(Знач Токен, Знач База, Знач Таблица, Знач Поле, Знач Наименование = "", Знач Описание = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Поле);
URL = "https://api.airtable.com/v0/meta/bases/"
+ База
+ "/tables/"
+ Таблица
+ "/fields/"
URL = "https://api.airtable.com/v0/meta/bases/"
+ База
+ "/tables/"
+ Таблица
+ "/fields/"
+ Поле;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура();
OPI_Инструменты.ДобавитьПоле("name" , Наименование, "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("description", Описание , "Строка", Параметры);
Ответ = OPI_Инструменты.Patch(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить поле (строковое)
// Получает описание поля строкового типа
//
//
// Параметры:
// Наименование - Строка - Наименование нового поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеСтроковое(Знач Наименование) Экспорт
Возврат ОписаниеПримитивногоПоля(Наименование, "richText");
КонецФункции
// Получить поле (числовое)
// Получает описание поля числового типа
//
//
// Параметры:
// Наименование - Строка - Наименование нового поля - title
// Точность - Число,Строка - Число знаков после запятой - precision
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеНомера(Знач Наименование, Знач Точность = 0) Экспорт
OPI_ПреобразованиеТипов.ПолучитьЧисло(Точность);
СтруктураОпций = Новый Структура("precision", Точность);
Возврат ОписаниеПримитивногоПоля(Наименование, "number", СтруктураОпций);
КонецФункции
// Получить поле (файл)
// Получает описание поля файлового типа
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеВложения(Знач Наименование) Экспорт
Возврат ОписаниеПримитивногоПоля(Наименование, "multipleAttachments");
КонецФункции
// Получить поле (флажок)
// Получает описание поля типа булево
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеФлажка(Знач Наименование) Экспорт
СтруктураОпций = Новый Структура("icon,color", "check", "yellowBright");
Возврат ОписаниеПримитивногоПоля(Наименование, "checkbox", СтруктураОпций);
КонецФункции
// Получить поле (дата)
// Получает описание поля типа дата
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеДаты(Знач Наименование) Экспорт
СтруктураФормата = Новый Структура("format,name", "YYYY-MM-DD", "iso");
СтруктураОпций = Новый Структура("dateFormat", СтруктураФормата);
Возврат ОписаниеПримитивногоПоля(Наименование, "date", СтруктураОпций);
КонецФункции
// Получить поле (email)
// Получает описание поля с электронной почтой
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеПочты(Знач Наименование) Экспорт
Возврат ОписаниеПримитивногоПоля(Наименование, "email");
КонецФункции
// Получить поле (телефон)
// Получает описание поля с номером телефона
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеТелефона(Знач Наименование) Экспорт
Возврат ОписаниеПримитивногоПоля(Наименование, "phoneNumber");
КонецФункции
// Получить поле (url)
// Получает описание поля с URL
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеСсылки(Знач Наименование) Экспорт
Возврат ОписаниеПримитивногоПоля(Наименование, "url");
КонецФункции
#КонецОбласти
@ -392,67 +392,67 @@
// Получить список записей
// Получает список записей выбранной таблицы
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Отступ - Строка - Иднтификатор следующей страницы данных из предыдущего запроса - offset
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ПолучитьСписокЗаписей(Знач Токен, Знач База, Знач Таблица, Знач Отступ = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура();
OPI_Инструменты.ДобавитьПоле("offset", Отступ, "Строка", Параметры);
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить запись
// Получает данные строки таблицы по идентификатору
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Запись - Строка - Идентификатор записи в таблице - record
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ПолучитьЗапись(Знач Токен, Знач База, Знач Таблица, Знач Запись) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Запись);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + "/" + Запись;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Создать записи
// Создает одну или массив записей по описанию или массиву описаний значений полей
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Данные - Структура, Массив из Структура - Набор или массив наборов пар Ключ : Значение > Поле : Показатель - data
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция СоздатьЗаписи(Знач Токен, Знач База, Знач Таблица, Знач Данные) Экспорт
@ -460,52 +460,52 @@
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(Данные);
Параметры = Новый Структура();
ДобавитьОписаниеДанных(Данные, Параметры);
ДобавитьОписаниеДанных(Данные, Параметры);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
Возврат Ответ;
КонецФункции
// Удалить записи
// Удаляет одну или массив записей по идентификаторам
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Записи - Строка, Массив из Строка - Идентификатор или массив индентификаторов записей - records
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция УдалитьЗаписи(Знач Токен, Знач База, Знач Таблица, Знач Записи) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьМассив(Записи);
СтрокаЗаписей = "";
Для Каждого Запись Из Записи Цикл
СтрокаЗаписей = СтрокаЗаписей
СтрокаЗаписей = СтрокаЗаписей
+ ?(ЗначениеЗаполнено(СтрокаЗаписей), "&", "?")
+ "records[]="
+ OPI_Инструменты.ЧислоВСтроку(Запись);
+ OPI_Инструменты.ЧислоВСтроку(Запись);
КонецЦикла;
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + СтрокаЗаписей;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -514,67 +514,67 @@
// Получить комментарии
// Получает список комментариев к записи в таблице
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Запись - Строка - Идентификатор записи в таблице - record
// Отступ - Строка - Иднтификатор следующей страницы данных из предыдущего запроса - offset
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ПолучитьКомментарии(Знач Токен, Знач База, Знач Таблица, Знач Запись, Знач Отступ = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Запись);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + "/" + Запись + "/comments";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура();
OPI_Инструменты.ДобавитьПоле("offset", Отступ, "Строка", Параметры);
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Создать комментарий
// Создает комментарий к записи в таблице
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Запись - Строка - Идентификатор записи в таблице - record
// Текст - Строка - Текст комментария - text
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция СоздатьКомментарий(Знач Токен, Знач База, Знач Таблица, Знач Запись, Знач Текст) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Запись);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + "/" + Запись + "/comments";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура();
OPI_Инструменты.ДобавитьПоле("text", Текст, "Строка", Параметры);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Изменить комментарий
// Изменяет текст существующего комментария
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
@ -582,54 +582,54 @@
// Запись - Строка - Идентификатор записи в таблице - record
// Комментарий - Строка - Идентификатор комментария - comment
// Текст - Строка - Новый текст комментария - text
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ИзменитьКомментарий(Знач Токен, Знач База, Знач Таблица, Знач Запись, Знач Комментарий, Знач Текст) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Запись);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Комментарий);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + "/" + Запись + "/comments/" + Комментарий;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура();
OPI_Инструменты.ДобавитьПоле("text", Текст, "Строка", Параметры);
Ответ = OPI_Инструменты.Patch(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Удалить комментарий
// Удаляет комментарий к записи таблицы
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Запись - Строка - Идентификатор записи в таблице - record
// Комментарий - Строка - Идентификатор комментария - comment
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция УдалитьКомментарий(Знач Токен, Знач База, Знач Таблица, Знач Запись, Знач Комментарий) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Запись);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Комментарий);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + "/" + Запись + "/comments/" + Комментарий;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -639,58 +639,58 @@
#Область СлужебныеПроцедурыИФункции
Функция ПолучитьЗаголовокАвторизации(Знач Токен)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
Заголовки = Новый Соответствие;
Заголовки.Вставить("Authorization", "Bearer " + Токен);
Возврат Заголовки;
КонецФункции
Функция СформироватьОписаниеТаблицы(Знач Наименование, Знач МассивПолей, Знач Описание = "")
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивПолей);
ОписаниеТаблицы = Новый Структура("name,fields", Наименование, МассивПолей);
OPI_Инструменты.ДобавитьПоле("description", Описание, "Строка", ОписаниеТаблицы);
Возврат ОписаниеТаблицы;
КонецФункции
Функция ОписаниеПримитивногоПоля(Знач Наименование, Знач Тип, Знач Опции = "")
СтруктураПоля = Новый Структура();
OPI_Инструменты.ДобавитьПоле("name" , Наименование, "Строка" , СтруктураПоля);
OPI_Инструменты.ДобавитьПоле("type" , Тип , "Строка" , СтруктураПоля);
OPI_Инструменты.ДобавитьПоле("options", Опции , "Коллекция", СтруктураПоля);
Возврат СтруктураПоля;
КонецФункции
Процедура ДобавитьОписаниеДанных(Знач Данные, Параметры)
Если ТипЗнч(Данные) = Тип("Массив") Тогда
МассивОтправки = Новый Массив;
Для Каждого ОписаниеЗаписи Из Данные Цикл
МассивОтправки.Добавить(Новый Структура("fields", ОписаниеЗаписи));
МассивОтправки.Добавить(Новый Структура("fields", ОписаниеЗаписи));
КонецЦикла;
OPI_Инструменты.ДобавитьПоле("records", МассивОтправки, "Массив", Параметры);
Иначе
OPI_Инструменты.ДобавитьПоле("fields", Данные, "Коллекция", Параметры);
OPI_Инструменты.ДобавитьПоле("fields", Данные, "Коллекция", Параметры);
КонецЕсли;
КонецПроцедуры
#КонецОбласти

1992
src/ru/OInt/core/Modules/OPI_Bitrix24.os
View File

File diff suppressed because it is too large Load Diff

544
src/ru/OInt/core/Modules/OPI_Dropbox.os
View File

File diff suppressed because it is too large Load Diff

340
src/ru/OInt/core/Modules/OPI_GoogleCalendar.os
View File

@ -43,131 +43,131 @@
// Создать календарь
// Создает пустой календарь
//
//
// Параметры:
// Токен - Строка - Токен - token
// Наименование - Строка - Наименование создаваемого календаря - title
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция СоздатьКалендарь(Знач Токен, Знач Наименование) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars";
Параметры = Новый Структура;
Параметры.Вставить("summary" , Наименование);
Параметры.Вставить("timeZone", "Europe/Moscow");
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить календарь
// Получает информацию о календаре по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьМетаданныеКалендаря(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Календарь;
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Календарь;
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Изменить календарь
// Изменяет свойства существуещего календаря
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// Наименование - Строка - Новое наименование - title
// Описание - Строка - Новое описание календаря - description
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ИзменитьМетаданныеКалендаря(Знач Токен
, Знач Календарь
, Знач Наименование = ""
, Знач Описание = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Описание);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Календарь;
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Наименование) Тогда
Параметры.Вставить("summary", Наименование);
КонецЕсли;
Если ЗначениеЗаполнено(Описание) Тогда
Параметры.Вставить("description", Описание);
КонецЕсли;
Ответ = OPI_Инструменты.Patch(URL, Параметры, Заголовки, Истина);
Возврат Ответ;
КонецФункции
// Очистить основной календарь
// Очищает список событий основного календаря
//
//
// Параметры:
// Токен - Строка - Токен - token
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ОчиститьОсновнойКалендарь(Знач Токен) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/primary/clear";
URL = "https://www.googleapis.com/calendar/v3/calendars/primary/clear";
Ответ = OPI_Инструменты.Post(URL, , Заголовки, Ложь);
Возврат Ответ;
КонецФункции
// Удалить календарь
// Удаляет календарь по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьКалендарь(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Календарь;
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Календарь;
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
@ -178,105 +178,105 @@
// Получить список календарей
// Получает массив календарей аккаунта
//
//
// Параметры:
// Токен - Строка - Токен - token
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Массив соответствий данных календарей
Функция ПолучитьСписокКалендарей(Знач Токен) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
МассивКалендарей = Новый Массив;
ПолучитьСписокКалендарейРекурсивно(Заголовки, МассивКалендарей);
Возврат МассивКалендарей;
КонецФункции
// Добавить календарь в список
// Добавляет существующий календарь в список пользователя
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ДобавитьКалендарьВСписок(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList";
Параметры = Новый Структура;
Параметры.Вставить("id", Календарь);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить календарь списка
// Получает календарь из списка пользователя по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьКалендарьСписка(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Календарь;
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Удалить календарь из списка
// Удаляет календарь из списка пользователя
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьКалендарьИзСписка(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Календарь;
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Изменить календарь списка
// Изменяет свойства календаря из списка пользователей
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// ОсновнойЦвет - Строка - HEX основного цвета (#ffffff) - primary
// ДополнительныйЦвет - Строка - HEX дополнительного цвета (#ffffff) - secondary
// Скрытый - Булево - Скрытый календарь - hidden
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ИзменитьКалендарьСписка(Знач Токен
@ -284,23 +284,23 @@
, Знач ОсновнойЦвет
, Знач ДополнительныйЦвет
, Знач Скрытый = Ложь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ОсновнойЦвет);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ДополнительныйЦвет);
OPI_ПреобразованиеТипов.ПолучитьБулево(Скрытый);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Календарь + "?colorRgbFormat=true";
Параметры = Новый Соответствие;
Параметры.Вставить("hidden" , Скрытый);
Параметры.Вставить("foregroundColor", ОсновнойЦвет);
Параметры.Вставить("backgroundColor", ДополнительныйЦвет);
Ответ = OPI_Инструменты.Put(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
@ -310,15 +310,15 @@
#Область РаботаССобытиями
// Получить описание события !NOCLI
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Пустой макет события
Функция ПолучитьОписаниеСобытия() Экспорт
ТекущаяДата = OPI_Инструменты.ПолучитьТекущуюДату();
Час = 3600;
Событие = Новый Соответствие;
Событие.Вставить("Описание" , ""); // Описание события
Событие.Вставить("Заголовок" , "Новое событие"); // Заголовок события
Событие.Вставить("МестоПроведения" , ""); // Строка описание места проведения
@ -328,149 +328,149 @@
Событие.Вставить("ОтправлятьУведомления" , Истина); // Признак отправки уведомлений участникам
Возврат Событие;
КонецФункции
// Получить список событий
// Получает список всех событий календаря
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Массив соответствий событий
Функция ПолучитьСписокСобытий(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
МассивСобытий = Новый Массив;
ПолучитьСписокСобытийРекурсивно(Заголовки, Календарь, МассивСобытий);
Возврат МассивСобытий;
КонецФункции
// Получить событие
// Получает событие по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// Событие - Строка - ID события - event
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьСобытие(Знач Токен, Знач Календарь, Знач Событие) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Событие);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
+ "/events/"
+ Событие;
+ Событие;
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Создать событие
// Создает новое событие
//
//
// Параметры:
// Токен - Строка - Токен - token
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// ОписаниеСобытия - Соответствие Из КлючИЗначение - Описание события - props
//
//
// Возвращаемое значение:
// Строка, Произвольный, HTTPОтвет, ДвоичныеДанные, Неопределено - ответ сервера Google
Функция СоздатьСобытие(Знач Токен, Знач Календарь, Знач ОписаниеСобытия) Экспорт
Функция СоздатьСобытие(Знач Токен, Знач Календарь, Знач ОписаниеСобытия) Экспорт
Возврат УправлениеСобытием(Токен, Календарь, ОписаниеСобытия);
КонецФункции
// Переместить событие
// Перемещает событие в другой календарь
//
//
// Параметры:
// Токен - Строка - Токен - token
// КалендарьИсточник - Строка - ID календаря источника - from
// КалендарьПриемник - Строка - ID календаря приемника - to
// Событие - Строка - ID события календаря источника - event
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПереместитьСобытие(Знач Токен, Знач КалендарьИсточник, Знач КалендарьПриемник, Знач Событие) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(КалендарьИсточник);
OPI_ПреобразованиеТипов.ПолучитьСтроку(КалендарьПриемник);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Событие);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ КалендарьИсточник
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ КалендарьИсточник
+ "/events/"
+ Событие
+ "/move?destination="
+ КалендарьПриемник;
+ КалендарьПриемник;
Ответ = OPI_Инструменты.Post(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Изменить событие
// Изменяет существующее событие
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// ОписаниеСобытия - Строка - Новое описание события - props
// Событие - Строка - ID события - event
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ИзменитьСобытие(Знач Токен, Знач Календарь, Знач ОписаниеСобытия, Знач Событие) Экспорт
Возврат УправлениеСобытием(Токен, Календарь, ОписаниеСобытия, Событие);
КонецФункции
// Удалить событие
// Удаляет событие по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// Событие - Строка - ID события - event
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьСобытие(Знач Токен, Знач Календарь, Знач Событие) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Событие);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
+ "/events/"
+ Событие;
+ Событие;
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
@ -482,51 +482,51 @@
#Область СлужебныеПроцедурыИФункции
Функция ПреобразоватьДату(Знач Дата)
OPI_ПреобразованиеТипов.ПолучитьДату(Дата);
СтруктураДаты = Новый Структура;
Если Не ТипЗнч(Дата) = Тип("Дата") Тогда
Возврат Неопределено;
КонецЕсли;
Если Дата = НачалоДня(Дата) Тогда
Если Дата = НачалоДня(Дата) Тогда
ФорматДаты = "ДФ=yyyy-MM-dd";
Поле = "date";
Иначе
ФорматДаты = "ДФ=yyyy-MM-ddTHH:mm:ssZ";
Поле = "dateTime";
КонецЕсли;
Дата = Формат(Дата, ФорматДаты);
СтруктураДаты.Вставить(Поле , Дата);
СтруктураДаты.Вставить("timeZone", "Europe/Moscow");
Возврат СтруктураДаты;
КонецФункции
Функция ПреобразоватьВложения(Знач Вложения)
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(Вложения);
МассивВложений = Новый Массив;
Если ТипЗнч(Вложения) = Тип("Соответствие") Или ТипЗнч(Вложения) = Тип("Структура") Тогда
Для Каждого Вложение Из Вложения Цикл
ТекущеВложение = Новый Структура;
ТекущеВложение.Вставить("title" , Вложение.Ключ);
ТекущеВложение.Вставить("fileUrl", Вложение.Значение);
МассивВложений.Добавить(ТекущеВложение);
КонецЦикла;
КонецЕсли;
Если МассивВложений.Количество() > 0 Тогда
Возврат МассивВложений;
Иначе
@ -536,19 +536,19 @@
КонецФункции
Функция УправлениеСобытием(Знач Токен, Знач Календарь, Знач ОписаниеСобытия, Знач Событие = "")
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Событие);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(ОписаниеСобытия);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
Существующее = ЗначениеЗаполнено(Событие);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
+ "/events"
+ ?(Существующее, "/" + Событие, "");
+ ?(Существующее, "/" + Событие, "");
Дата0 = ОписаниеСобытия["ДатаНачала"];
Дата1 = ОписаниеСобытия["ДатаОкончания"];
Вложения = ОписаниеСобытия["МассивURLФайловВложений"];
@ -556,85 +556,85 @@
Уведомления = ?(ОписаниеСобытия["ОтправлятьУведомления"] = Неопределено
, Ложь
, ОписаниеСобытия["ОтправлятьУведомления"]);
Параметры = Новый Структура;
Параметры.Вставить("summary" , ОписаниеСобытия["Заголовок"]);
Параметры.Вставить("description", ОписаниеСобытия["Описание"]);
Параметры.Вставить("location" , ОписаниеСобытия["МестоПроведения"]);
Параметры.Вставить("start" , ПреобразоватьДату(Дата0));
Параметры.Вставить("end" , ПреобразоватьДату(Дата1));
Параметры.Вставить("attachments", Вложения);
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("sendUpdates" , ?(Уведомления, "all", "none"));
Параметры.Вставить("attachments", Вложения);
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("sendUpdates" , ?(Уведомления , "all" , "none"));
ПараметрыURL.Вставить("supportsAttachments" , ?(ЗначениеЗаполнено(Вложения), "true", "false"));
URL = URL + OPI_Инструменты.ПараметрыЗапросаВСтроку(ПараметрыURL);
OPI_Инструменты.УдалитьПустыеПоляКоллекции(Параметры);
Если Существующее Тогда
Ответ = OPI_Инструменты.Patch(URL, Параметры, Заголовки, Истина);
Иначе
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки, Истина);
КонецЕсли;
Возврат Ответ;
КонецФункции
Процедура ПолучитьСписокКалендарейРекурсивно(Знач Заголовки, МассивКалендарей, Страница = "")
Процедура ПолучитьСписокКалендарейРекурсивно(Знач Заголовки, МассивКалендарей, Страница = "")
Items = "items";
NPT = "nextPageToken";
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Страница) Тогда
Параметры.Вставить("pageToken", Страница);
КонецЕсли;
Результат = OPI_Инструменты.Get("https://www.googleapis.com/calendar/v3/users/me/calendarList"
, Параметры
, Заголовки);
Календари = Результат[Items];
Страница = Результат[NPT];
Для Каждого Календарь Из Календари Цикл
МассивКалендарей.Добавить(Календарь);
КонецЦикла;
МассивКалендарей.Добавить(Календарь);
КонецЦикла;
Если Календари.Количество() > 0 И ЗначениеЗаполнено(Страница) Тогда
ПолучитьСписокКалендарейРекурсивно(Заголовки, МассивКалендарей, Страница);
ПолучитьСписокКалендарейРекурсивно(Заголовки, МассивКалендарей, Страница);
КонецЕсли;
КонецПроцедуры
Процедура ПолучитьСписокСобытийРекурсивно(Знач Заголовки, Знач Календарь, МассивСобытий, Страница = "")
Процедура ПолучитьСписокСобытийРекурсивно(Знач Заголовки, Знач Календарь, МассивСобытий, Страница = "")
Items = "items";
NPT = "nextPageToken";
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Страница) Тогда
Параметры.Вставить("pageToken", Страница);
КонецЕсли;
Результат = OPI_Инструменты.Get("https://www.googleapis.com/calendar/v3/calendars/" + Календарь + "/events"
, Параметры
, Заголовки);
События = Результат[Items];
Страница = Результат[NPT];
Для Каждого Событие Из События Цикл
МассивСобытий.Добавить(Событие);
КонецЦикла;
МассивСобытий.Добавить(Событие);
КонецЦикла;
Если События.Количество() > 0 И ЗначениеЗаполнено(Страница) Тогда
ПолучитьСписокСобытийРекурсивно(Заголовки, МассивСобытий, Страница);
ПолучитьСписокСобытийРекурсивно(Заголовки, МассивСобытий, Страница);
КонецЕсли;
КонецПроцедуры
#КонецОбласти

422
src/ru/OInt/core/Modules/OPI_GoogleDrive.os
View File

@ -43,277 +43,277 @@
// Получить информацию об объекте
// Получает информацию о папке или файле по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор файла или каталога - object
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьИнформациюОбОбъекте(Знач Токен, Знач Идентификатор) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
Параметры = Новый Структура;
Параметры.Вставить("fields", "*");
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить список каталогов
// Получает список каталогов диска
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИмяСодержит - Строка - Отбор по имени - querry
// Подробно - Булево - Добавляет список файлов к полям каталога - depth
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Массив соответствий каталогов
Функция ПолучитьСписокКаталогов(Знач Токен, Знач ИмяСодержит = "", Знач Подробно = Ложь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИмяСодержит);
OPI_ПреобразованиеТипов.ПолучитьБулево(Подробно);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
МассивОбъектов = Новый Массив;
Отбор = Новый Массив;
Отбор.Добавить("mimeType = 'application/vnd.google-apps.folder'");
Если ЗначениеЗаполнено(ИмяСодержит) Тогда
Отбор.Добавить("name contains '" + ИмяСодержит + "'");
КонецЕсли;
ПолучитьСписокОбъектовРекурсивно(Заголовки, МассивОбъектов, Подробно, Отбор);
Если Подробно Тогда
РазложитьОбъектыПодробно(Токен, МассивОбъектов);
РазложитьОбъектыПодробно(Токен, МассивОбъектов);
КонецЕсли;
Возврат МассивОбъектов;
КонецФункции
// Получить список файлов
// Получает список файлов
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИмяСодержит - Строка - Отбор по имени - querry
// Каталог - Строка - Отбор по ID каталога родителя - catalog
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Массив соответствий файлов
Функция ПолучитьСписокФайлов(Знач Токен, Знач ИмяСодержит = "", Знач Каталог = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИмяСодержит);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Каталог);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
МассивОбъектов = Новый Массив;
Отбор = Новый Массив;
Отбор.Добавить("mimeType != 'application/vnd.google-apps.folder'");
Если ЗначениеЗаполнено(ИмяСодержит) Тогда
Отбор.Добавить("name contains '" + ИмяСодержит + "'");
КонецЕсли;
Если ЗначениеЗаполнено(Каталог) Тогда
Отбор.Добавить("'" + Каталог + "' in parents");
КонецЕсли;
ПолучитьСписокОбъектовРекурсивно(Заголовки, МассивОбъектов, , Отбор);
Возврат МассивОбъектов;
КонецФункции
// Загрузить файл
// Загружает файл на диск
//
//
// Параметры:
// Токен - Строка - Токен - token
// Файл - ДвоичныеДанные,Строка - Загружаемый файл - file
// Описание - Соответствие Из КлючИЗначение - См. ПолучитьОписаниеФайла - props - JSON описания или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ЗагрузитьФайл(Знач Токен, Знач Файл, Знач Описание) Экспорт
Возврат УправлениеФайлом(Токен, Файл, Описание);
Возврат УправлениеФайлом(Токен, Файл, Описание);
КонецФункции
// Создать папку
// Создает пустой каталог на диске
//
//
// Параметры:
// Токен - Строка - Токен - token
// Имя - Строка - Имя папки - title
// Родитель - Строка - Родитель - catalog
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция СоздатьПапку(Знач Токен, Знач Имя, Знач Родитель = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Имя);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Родитель);
Описание = Новый Соответствие;
Описание.Вставить("MIME" , "application/vnd.google-apps.folder");
Описание.Вставить("Имя" , Имя);
Описание.Вставить("Описание", "");
Описание.Вставить("Родитель", ?(ЗначениеЗаполнено(Родитель), Родитель, "root"));
Возврат УправлениеФайлом(Токен, , Описание);
КонецФункции
// Скачать файл
// Получает файл по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор файла - object
// ПутьСохранения - Строка - Путь сохранения файла - out
//
// ПутьСохранения - Строка - Путь сохранения файла - out
//
// Возвращаемое значение:
// ДвоичныеДанные,Строка - Двоичные данные или путь к файлу при указании параметра ПутьСохранения
Функция СкачатьФайл(Знач Токен, Знач Идентификатор, Знач ПутьСохранения = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
Параметры = Новый Соответствие;
Параметры.Вставить("alt", "media");
Ответ = OPI_Инструменты.Get(URL, Параметры , Заголовки, ПутьСохранения);
Возврат Ответ;
КонецФункции
// Скоприровать объект
// Копирует файл или каталог
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор объекта - object
// НовоеИмя - Строка - Новое имя объекта - title
// НовыйРодитель - Строка - Новый каталог размещения - catalog
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция СкопироватьОбъект(Знач Токен, Знач Идентификатор, Знач НовоеИмя = "", Знач НовыйРодитель = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(НовоеИмя);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
OPI_ПреобразованиеТипов.ПолучитьСтроку(НовыйРодитель);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор + "/copy";
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор + "/copy";
Параметры = Новый Структура;
Если ЗначениеЗаполнено(НовоеИмя) Тогда
Параметры.Вставить("name", НовоеИмя);
КонецЕсли;
Если ЗначениеЗаполнено(НовыйРодитель) Тогда
МассивРодителей = Новый Массив;
МассивРодителей.Добавить(НовыйРодитель);
Параметры.Вставить("parents", МассивРодителей);
КонецЕсли;
Ответ = OPI_Инструменты.Post(URL, Параметры , Заголовки, Истина);
Возврат Ответ;
КонецФункции
// Обновить файл
// Обновляет двоичные данные файла
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор обновляемого объекта - object
// Файл - ДвоичныеДанные,Строка - Файл источник обновления - file
// НовоеИмя - Строка - Новое имя файла (если необходимо) - title
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ОбновитьФайл(Знач Токен, Знач Идентификатор, Знач Файл, Знач НовоеИмя = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
OPI_ПреобразованиеТипов.ПолучитьСтроку(НовоеИмя);
OPI_ПреобразованиеТипов.ПолучитьДвоичныеДанные(Файл);
Если ЗначениеЗаполнено(НовоеИмя) Тогда
Описание = Новый Соответствие;
Описание.Вставить("Имя", НовоеИмя);
Иначе
Описание = "";
КонецЕсли;
Возврат УправлениеФайлом(Токен, Файл, Описание, Идентификатор);
КонецФункции
// Удалить объект
// Удаляет файл или каталог по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор объекта для удаления - object
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьОбъект(Знач Токен, Знач Идентификатор) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Получить описание файла !NOCLI
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Описание файла
Функция ПолучитьОписаниеФайла() Экспорт
Описание = Новый Соответствие;
Описание.Вставить("MIME" , "image/jpeg"); // MIME-тип загружаемого файла
Описание.Вставить("Имя" , "Новый файл.jpg"); // Имя файла с расширением
Описание.Вставить("Описание" , "Это новый файл"); // Описание файла
Описание.Вставить("Родитель" , "root"); // ID каталога загрузки или "root" для загрузки в корень
Возврат Описание;
КонецФункции
#КонецОбласти
@ -322,107 +322,107 @@
// Создать комментарий
// Создает комментарий к файлу или каталогу
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор объекта, для которого необходим комментарий - object
// Идентификатор - Строка - Идентификатор объекта, для которого необходим комментарий - object
// Комментарий - Строка - Текст комментария - text
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция СоздатьКомментарий(Знач Токен, Знач Идентификатор, Знач Комментарий) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Комментарий);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор + "/comments?fields=*";
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор + "/comments?fields=*";
Параметры = Новый Структура;
Параметры.Вставить("content", Комментарий);
Ответ = OPI_Инструменты.POST(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить комментарий
// Получает комментарий по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИДОбъекта - Строка - Идентификатор файла или каталога размещения комментария - object
// ИДКомментария - Строка - Идентификатор комментария - comment
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьКомментарий(Знач Токен, Знач ИДОбъекта, Знач ИДКомментария) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИДОбъекта);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИДКомментария);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments/" + ИДКомментария;
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments/" + ИДКомментария;
Параметры = Новый Структура;
Параметры.Вставить("fields", "*");
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить список комментариев
// Получает список всех комментариев объекта
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИДОбъекта - Строка - Идентификатор объекта - object
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьСписокКомментариев(Знач Токен, Знач ИДОбъекта) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИДОбъекта);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments";
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments";
Параметры = Новый Структура;
Параметры.Вставить("fields", "*");
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Удалить комментарий
// Удаляет комментарий по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИДОбъекта - Строка - Идентификатор файла или каталога размещения комментария - object
// ИДКомментария - Строка - Идентификатор комментария - comment
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьКомментарий(Знач Токен, Знач ИДОбъекта, Знач ИДКомментария) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИДОбъекта);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИДКомментария);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments/" + ИДКомментария;
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments/" + ИДКомментария;
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
@ -433,59 +433,59 @@
#Область СлужебныеПроцедурыИФункции
Процедура ПолучитьСписокОбъектовРекурсивно(Знач Заголовки, МассивОбъектов, Подробно = Ложь, Отбор = "", Страница = "")
Процедура ПолучитьСписокОбъектовРекурсивно(Знач Заголовки, МассивОбъектов, Подробно = Ложь, Отбор = "", Страница = "")
URL = "https://www.googleapis.com/drive/v3/files";
Files = "files";
NPT = "nextPageToken";
Параметры = Новый Структура;
Параметры.Вставить("fields", "*");
Если ЗначениеЗаполнено(Страница) Тогда
Параметры.Вставить("pageToken", Страница);
КонецЕсли;
Если ЗначениеЗаполнено(Отбор) И ТипЗнч(Отбор) = Тип("Массив") Тогда
Если ЗначениеЗаполнено(Отбор) И ТипЗнч(Отбор) = Тип("Массив") Тогда
ОтборСтрока = СтрСоединить(Отбор, " and ");
Параметры.Вставить("q", ОтборСтрока);
Параметры.Вставить("q", ОтборСтрока);
КонецЕсли;
Результат = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Объекты = Результат[Files];
Страница = Результат[NPT];
Для Каждого ТекущийОбъект Из Объекты Цикл
МассивОбъектов.Добавить(ТекущийОбъект);
КонецЦикла;
КонецЦикла;
Если Объекты.Количество() > 0 И ЗначениеЗаполнено(Страница) Тогда
ПолучитьСписокОбъектовРекурсивно(Заголовки, МассивОбъектов, Подробно, Отбор, Страница);
ПолучитьСписокОбъектовРекурсивно(Заголовки, МассивОбъектов, Подробно, Отбор, Страница);
КонецЕсли;
КонецПроцедуры
Процедура РазложитьОбъектыПодробно(Знач Токен, МассивОбъектов)
Процедура РазложитьОбъектыПодробно(Знач Токен, МассивОбъектов)
Для Каждого ТекущийОбъект Из МассивОбъектов Цикл
МассивФайлов = Новый Массив;
ТекущийИД = ТекущийОбъект["id"];
Результат = ПолучитьСписокФайлов(Токен, , ТекущийИД);
Для Каждого Файл Из Результат Цикл
МассивФайлов.Добавить(Файл);
МассивФайлов.Добавить(Файл);
КонецЦикла;
ТекущийОбъект.Вставить("files", МассивФайлов);
КонецЦикла;
КонецПроцедуры
Процедура СформироватьПараметрыЗагрузкиФайла(Описание)
СформированноеОписание = Новый Соответствие;
OPI_Инструменты.УдалитьПустыеПоляКоллекции(Описание);
@ -495,81 +495,81 @@
СоответствиеПолей.Вставить("Описание" , "description");
СоответствиеПолей.Вставить("Родитель" , "parents");
СоответствиеПолей.Вставить("Расширение", "fileExtension");
Для Каждого Элемент Из Описание Цикл
Если Элемент.Ключ = "Родитель" Тогда
ТекущееЗначение = Новый Массив;
ТекущееЗначение.Добавить(Элемент.Значение);
Иначе
ТекущееЗначение = Элемент.Значение;
КонецЕсли;
ИмяПоля = СоответствиеПолей.Получить(Элемент.Ключ);
СформированноеОписание.Вставить(ИмяПоля, ТекущееЗначение);
КонецЦикла;
Описание = СформированноеОписание;
КонецПроцедуры
Функция УправлениеФайлом(Знач Токен, Знач Файл = "", Знач Описание = "", Знач Идентификатор = "")
Функция УправлениеФайлом(Знач Токен, Знач Файл = "", Знач Описание = "", Знач Идентификатор = "")
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
Если ЗначениеЗаполнено(Описание) Тогда
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(Описание);
КонецЕсли;
MimeType = "mimeType";
Если ЗначениеЗаполнено(Идентификатор) Тогда
MIME = ПолучитьИнформациюОбОбъекте(Токен, Идентификатор)[MimeType];
Иначе
MIME = Описание["MIME"];
КонецЕсли;
КонецЕсли;
Если Не ЗначениеЗаполнено(Описание) Тогда
Описание = Новый Соответствие;
КонецЕсли;
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
СформироватьПараметрыЗагрузкиФайла(Описание);
ОписаниеJSON = OPI_Инструменты.JSONСтрокой(Описание);
СоответствиеФайла = Новый Соответствие;
Если ЗначениеЗаполнено(Файл) Тогда
РазмерЧасти = 268435457;
РазмерЧасти = 268435457;
Размер = OPI_Инструменты.ПреобразоватьДанныеСПолучениемРазмера(Файл, РазмерЧасти);
СоответствиеФайла.Вставить(Файл, MIME);
Если Размер < РазмерЧасти И ТипЗнч(Файл) = Тип("ДвоичныеДанные") Тогда
Ответ = ЗагрузитьМалыйФайл(ОписаниеJSON, СоответствиеФайла, Заголовки, Идентификатор);
Иначе
Ответ = ЗагрузитьБольшойФайл(Описание, СоответствиеФайла, Заголовки, Идентификатор);
КонецЕсли;
Иначе
Ответ = ЗагрузитьМалыйФайл(ОписаниеJSON, СоответствиеФайла, Заголовки, Идентификатор);
Ответ = ЗагрузитьМалыйФайл(ОписаниеJSON, СоответствиеФайла, Заголовки, Идентификатор);
КонецЕсли;
Возврат Ответ;
КонецФункции
Функция ЗагрузитьМалыйФайл(Знач Описание, Знач СоответствиеФайла, Знач Заголовки, Знач Идентификатор = "")
URL = "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart";
Если ЗначениеЗаполнено(Идентификатор) Тогда
URL = СтрЗаменить(URL, "/files", "/files/" + Идентификатор);
Ответ = OPI_Инструменты.PatchMultipartRelated(URL, Описание, СоответствиеФайла, Заголовки);
@ -578,149 +578,149 @@
КонецЕсли;
Возврат Ответ;
КонецФункции
Функция ЗагрузитьБольшойФайл(Знач Описание, Знач СоответствиеФайла, Знач Заголовки, Знач Идентификатор = "")
Для Каждого Файл Из СоответствиеФайла Цикл
Двоичные = Файл.Ключ;
Прервать;
КонецЦикла;
URL = "https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable";
Если ЗначениеЗаполнено(Идентификатор) Тогда
URL = СтрЗаменить(URL, "/files", "/files/" + Идентификатор);
Ответ = OPI_Инструменты.Patch(URL, Описание, Заголовки, Истина, Истина);
Иначе
Ответ = OPI_Инструменты.Post(URL, Описание, Заголовки, Истина, Истина);
КонецЕсли;
АдресЗагрузки = Ответ.Заголовки["Location"];
Если Не ЗначениеЗаполнено(АдресЗагрузки) Тогда
OPI_Инструменты.ОбработатьОтвет(Ответ);
Возврат Ответ;
КонецЕсли;
ОтветЗагрузки = ЗагрузитьФайлЧастями(Двоичные, АдресЗагрузки);
Ответ = ?(ЗначениеЗаполнено(ОтветЗагрузки), ОтветЗагрузки, Ответ);
OPI_Инструменты.ОбработатьОтвет(Ответ);
Возврат Ответ;
КонецФункции
Функция ЗагрузитьФайлЧастями(Знач Двоичные, Знач АдресЗагрузки)
Ответ = "";
РазмерЧасти = 268435456;
ПрочитаноБайт = 0;
Ответ = "";
РазмерЧасти = 268435456;
ПрочитаноБайт = 0;
ТекущаяПозиция = 0;
ОбщийРазмер = Двоичные.Размер();
СтрОбщийРазмер = OPI_Инструменты.ЧислоВСтроку(ОбщийРазмер);
ЧтениеДанных = Новый ЧтениеДанных(Двоичные);
ИсходныйПоток = ЧтениеДанных.ИсходныйПоток();
Пока ПрочитаноБайт < ОбщийРазмер Цикл
ПрочитаноБайт = ИсходныйПоток.ТекущаяПозиция();
Результат = ЧтениеДанных.Прочитать(РазмерЧасти);
ТекущиеДанные = Результат.ПолучитьДвоичныеДанные();
РазмерТекущих = ТекущиеДанные.Размер();
СледующаяПозиция = ТекущаяПозиция + РазмерТекущих - 1;
СледующаяПозиция = ТекущаяПозиция + РазмерТекущих - 1;
Если Не ЗначениеЗаполнено(ТекущиеДанные) Тогда
Прервать;
КонецЕсли;
ЗаголовокПотока = "bytes "
+ OPI_Инструменты.ЧислоВСтроку(ТекущаяПозиция)
+ "-"
+ OPI_Инструменты.ЧислоВСтроку(СледующаяПозиция)
+ "/"
+ "-"
+ OPI_Инструменты.ЧислоВСтроку(СледующаяПозиция)
+ "/"
+ СтрОбщийРазмер;
ДопЗаголовки = Новый Соответствие;
ДопЗаголовки.Вставить("Content-Length", OPI_Инструменты.ЧислоВСтроку(РазмерТекущих));
ДопЗаголовки.Вставить("Content-Range" , ЗаголовокПотока);
ДопЗаголовки.Вставить("Content-Range" , ЗаголовокПотока);
ДопЗаголовки.Вставить("Content-Type" , "application/octet-stream");
Ответ = OPI_Инструменты.Put(АдресЗагрузки, ТекущиеДанные, ДопЗаголовки, Ложь, Истина);
РезультатПроверки = ПроверитьЗагрузкуЧасти(Ответ, СтрОбщийРазмер, ДопЗаголовки, АдресЗагрузки, ТекущаяПозиция);
Если ЗначениеЗаполнено(РезультатПроверки) Тогда
Возврат РезультатПроверки;
КонецЕсли;
КБайт = 1024;
МБайт = КБайт * КБайт;
Сообщить(OPI_Инструменты.ИнформацияОПрогрессе(ТекущаяПозиция, ОбщийРазмер, "МБ", МБайт));
ВыполнитьСборкуМусора();
ОсвободитьОбъект(ТекущиеДанные);
КонецЦикла;
Возврат Ответ;
КонецФункции
Функция ПроверитьЗагрузкуЧасти(Ответ, СтрОбщийРазмер, ДопЗаголовки, АдресЗагрузки, ТекущаяПозиция)
НачалоКодовОшибок = 400;
КонецКодовПадений = 600;
НачалоКодовУспеха = 200;
КонецКодовУспеха = 300;
Перенаправление = 308;
Если Ответ.КодСостояния >= НачалоКодовОшибок И Ответ.КодСостояния < КонецКодовПадений Тогда
ЗаголовокПотока = "bytes */" + СтрОбщийРазмер;
ДопЗаголовки.Вставить("Content-Range" , ЗаголовокПотока);
ОтветПроверки = OPI_Инструменты.Put(АдресЗагрузки, "", ДопЗаголовки, Ложь, Истина);
Если ОтветПроверки.КодСостояния >= НачалоКодовУспеха И ОтветПроверки.КодСостояния < КонецКодовУспеха Тогда
OPI_Инструменты.ОбработатьОтвет(ОтветПроверки);
Возврат ОтветПроверки;
ИначеЕсли ОтветПроверки.КодСостояния = Перенаправление Тогда
ЗагруженныеДанные = Ответ.Заголовки["Range"];
Иначе
OPI_Инструменты.ОбработатьОтвет(Ответ);
Возврат Ответ;
КонецЕсли;
Иначе
ЗагруженныеДанные = Ответ.Заголовки["Range"];
КонецЕсли;
Если Не ЗначениеЗаполнено(ЗагруженныеДанные) Тогда
OPI_Инструменты.ОбработатьОтвет(Ответ);
Возврат Ответ;
КонецЕсли;
ЗагруженныеДанные = СтрЗаменить(ЗагруженныеДанные, "bytes=", "");
МассивИнформации = СтрРазделить(ЗагруженныеДанные, "-", Ложь);
НеобходимоЧастей = 2;
Если Не МассивИнформации.Количество() = НеобходимоЧастей Тогда
OPI_Инструменты.ОбработатьОтвет(Ответ);
Возврат Ответ;
КонецЕсли;
ТекущаяПозиция = Число(МассивИнформации[1]) + 1;
Возврат "";
КонецФункции
#КонецОбласти

208
src/ru/OInt/core/Modules/OPI_GoogleSheets.os
View File

@ -43,90 +43,90 @@
// Создать книгу
// Создает новую книгу
//
//
// Параметры:
// Токен - Строка - Токен - token
// Наименование - Строка - Наименование - title
// МассивИменЛистов - Массив из Строка - Массив имен для добавления новых листов в книгу - sheets
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция СоздатьКнигу(Знач Токен, Знач Наименование, Знач МассивИменЛистов) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивИменЛистов);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets";
Свойства = Новый Структура("title" , Наименование);
Листы = Новый Массив;
ЗаполнитьМассивЛистов(МассивИменЛистов, Листы);
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("properties", Свойства, "Коллекция", Параметры);
OPI_Инструменты.ДобавитьПоле("sheets" , Листы , "Коллекция", Параметры);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить книгу
// Получает информацию о книге по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор книги - spreadsheet
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьКнигу(Знач Токен, Знач Идентификатор) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Идентификатор;
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Изменить наименование книги
// Изменяет наименование существующей книги
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - ID книги - spreadsheet
// Наименование - Строка - Новое наименование - title
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ИзменитьНаименованиеКниги(Знач Токен, Знач Книга, Знач Наименование) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + ":batchUpdate";
Изменение = Новый Структура("title", Наименование);
ЗапросИзменения = Новый Структура("properties,fields", Изменение, "title");
Запрос = Новый Структура("updateSpreadsheetProperties", ЗапросИзменения);
МассивЗапросов = Новый Массив;
МассивЗапросов.Добавить(Запрос);
Параметры = Новый Структура("requests", МассивЗапросов);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -135,95 +135,95 @@
// Добавить лист
// Добавляет новый лист в книгу
//
//
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - Идентификатор книги - spreadsheet
// Наименование - Строка - Наименование нового листа - title
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ДобавитьЛист(Знач Токен, Знач Книга, Знач Наименование) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + ":batchUpdate";
Лист = СоздатьЛист(Наименование);
Запросы = Новый Массив;
Изменение = Новый Структура("addSheet", Лист);
Запросы.Добавить(Изменение);
Параметры = Новый Структура("requests", Запросы);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Удалить лист
// Удаляет лист из книги
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - Идентификатор книги - spreadsheet
// Лист - Строка - Идентификатор удаляемого листа - sheet
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьЛист(Знач Токен, Знач Книга, Знач Лист) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Лист);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + ":batchUpdate";
Запросы = Новый Массив;
Лист = Новый Структура("sheetId" , Лист);
Изменение = Новый Структура("deleteSheet", Лист);
Запросы.Добавить(Изменение);
Параметры = Новый Структура("requests", Запросы);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Копировать лист
// Копирует лист из одной книги в другую
//
//
// Параметры:
// Токен - Строка - Токен - token
// Откуда - Строка - ID книги источника - from
// Куда - Строка - ID книги приемника - to
// Лист - Строка - ID копируемого листа - sheet
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция КопироватьЛист(Знач Токен, Знач Откуда, Знач Куда, Знач Лист) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Откуда);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Куда);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Лист);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/"
+ Откуда
+ "/sheets/"
+ Лист
+ ":copyTo";
Параметры = Новый Структура("destinationSpreadsheetId", Куда);
Параметры = Новый Структура("destinationSpreadsheetId", Куда);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -232,14 +232,14 @@
// Установить значения ячеек
// Устанавливает значения ячеек листа
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - ID книги - spreadsheet
// Книга - Строка - ID книги - spreadsheet
// СоответствиеЗначений - Соответствие Из КлючИЗначение - Данные заполнения, где ключ это имя ячейки вида A1 - data
// Лист - Строка - Имя листа (первый лист по умолчанию) - sheetname
// ОсновноеИзмерение - Строка - Основное измерение при заполнении диапазона массивом - dim
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УстановитьЗначенияЯчеек(Знач Токен
@ -247,90 +247,90 @@
, Знач СоответствиеЗначений
, Знач Лист = ""
, Знач ОсновноеИзмерение = "COLUMNS") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(СоответствиеЗначений);
Если Не ТипЗнч(СоответствиеЗначений) = Тип("Структура")
Если Не ТипЗнч(СоответствиеЗначений) = Тип("Структура")
И Не ТипЗнч(СоответствиеЗначений) = Тип("Соответствие") Тогда
Возврат "Не удалось привести структуру значений к коллекции";
КонецЕсли;
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + "/values:batchUpdate";
МассивДанных = СформироватьМассивДанныхЯчеек(СоответствиеЗначений, ОсновноеИзмерение, Лист);
Параметры = Новый Структура("data,valueInputOption", МассивДанных, "USER_ENTERED");
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Очистить ячейки
// Очищает значение в ячейках
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - ID книги - spreadsheet
// МассивЯчеек - Массив из Строка - Массив ячеек вида А1 для очистки - cells
// Лист - Строка - Имя листа (первый лист по умолчанию) - sheetname
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ОчиститьЯчейки(Знач Токен, Знач Книга, Знач МассивЯчеек, Знач Лист = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивЯчеек);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + "/values:batchClear";
СформироватьМассивИменЯчеек(МассивЯчеек, Лист);
Параметры = Новый Структура("ranges", МассивЯчеек);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить значения ячеек
// Получает значения ячеек таблицы
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - ID книги - spreadsheet
// МассивЯчеек - Массив из Строка - Массив ячеек вида А1 для получения (весь лист, если не заполнено) - cells
// Лист - Строка - Имя листа (первый лист по умолчанию) - sheetname
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьЗначенияЯчеек(Знач Токен, Знач Книга, Знач МассивЯчеек = "", Знач Лист = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + "/values:batchGet";
Если ЗначениеЗаполнено(МассивЯчеек) Тогда
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивЯчеек);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивЯчеек);
СформироватьМассивИменЯчеек(МассивЯчеек, Лист);
Первый = Истина;
Первый = Истина;
Для Каждого Ячейка Из МассивЯчеек Цикл
Разделитель = ?(Первый, "?", "&");
URL = URL + Разделитель + "ranges=" + Ячейка;
Первый = Ложь;
КонецЦикла;
Иначе
URL = URL + "?ranges='" + Лист + "'";
URL = URL + "?ranges ='" + Лист + "'";
КонецЕсли;
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -340,75 +340,75 @@
#Область СлужебныеПроцедурыИФункции
Процедура ЗаполнитьМассивЛистов(Знач МассивИмен, МассивЛистов)
Для Каждого ИмяЛиста Из МассивИмен Цикл
Лист = СоздатьЛист(ИмяЛиста);
МассивЛистов.Добавить(Лист);
КонецЦикла;
КонецПроцедуры
Процедура ДобавитьИмяЛиста(Ячейка, Знач Лист)
Если ЗначениеЗаполнено(Лист) Тогда
Ячейка = "'" + Лист + "'!" + Ячейка;
КонецЕсли;
КонецПроцедуры
Функция СоздатьЛист(Знач Наименование)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
СвойстваЛиста = Новый Структура("title" , Наименование);
Лист = Новый Структура("properties", СвойстваЛиста);
Возврат Лист;
КонецФункции
Функция СформироватьМассивДанныхЯчеек(Знач СтруктураЗначений, Знач ОсновноеИзмерение, Знач Лист)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Лист);
МассивДанных = Новый Массив;
Для Каждого ДанныеЯчейки Из СтруктураЗначений Цикл
ТекущееЗначение = ДанныеЯчейки.Значение;
ТекущийКлюч = ДанныеЯчейки.Ключ;
ДобавитьИмяЛиста(ТекущийКлюч, Лист);
OPI_ПреобразованиеТипов.ПолучитьМассив(ТекущееЗначение);
ТекущиеДанные = Новый Соответствие;
ТекущийМассив = Новый Массив;
ТекущийМассив.Добавить(ТекущееЗначение);
OPI_Инструменты.ДобавитьПоле("range" , ТекущийКлюч , "Строка", ТекущиеДанные);
OPI_Инструменты.ДобавитьПоле("values" , ТекущийМассив , "Массив", ТекущиеДанные);
OPI_Инструменты.ДобавитьПоле("majorDimension", ОсновноеИзмерение, "Строка", ТекущиеДанные);
МассивДанных.Добавить(ТекущиеДанные);
КонецЦикла;
Возврат МассивДанных;
КонецФункции
Процедура СформироватьМассивИменЯчеек(Знач МассивИмен, Знач Лист)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Лист);
Для Н = 0 По МассивИмен.ВГраница() Цикл
OPI_ПреобразованиеТипов.ПолучитьСтроку(Лист);
Для Н = 0 По МассивИмен.ВГраница() Цикл
ДобавитьИмяЛиста(МассивИмен[Н], Лист);
КонецЦикла;
КонецПроцедуры
#КонецОбласти

68
src/ru/OInt/core/Modules/OPI_GoogleWorkspace.os
View File

@ -41,97 +41,97 @@
// Сформировать ссылку получения кода
// Возвращает URL для авторизации в браузере
//
//
// Параметры:
// ClientID - Строка - Client ID - id
// Calendar - Булево - разрешение на методы Calendar - calendar
// Drive - Булево - разрешение на методы Drive - drive
// Sheets - Булево - разрешение на методы Sheets - sheets
//
//
// Возвращаемое значение:
// Строка - Ссылка получения кода
Функция СформироватьСсылкуПолученияКода(Знач ClientID
, Знач Calendar = Истина
, Знач Drive = Истина
, Знач Sheets = Истина) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientID);
OPI_ПреобразованиеТипов.ПолучитьБулево(Calendar);
OPI_ПреобразованиеТипов.ПолучитьБулево(Sheets);
OPI_ПреобразованиеТипов.ПолучитьБулево(Drive);
URL = "https://accounts.google.com/o/oauth2/auth";
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("response_type", "code");
ПараметрыURL.Вставить("client_id" , ClientID);
ПараметрыURL.Вставить("redirect_uri" , "http://localhost");
ПараметрыURL.Вставить("access_type" , "offline");
ПараметрыURL.Вставить("scope" , ПолучитьСписокРазрешений(Calendar, Drive, Sheets));
URL = URL + OPI_Инструменты.ПараметрыЗапросаВСтроку(ПараметрыURL);
Возврат URL;
КонецФункции
// Получить токен по коду
// Получает токен по коду из авторизации в бразуере
//
//
// Параметры:
// ClientID - Строка - Client ID - id
// ClientSecret - Строка - Client secret - secret
// Code - Строка - Code из браузера - code
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьТокенПоКоду(Знач ClientID, Знач ClientSecret, Знач Code) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientID);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientSecret);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Code);
URL = "https://accounts.google.com/o/oauth2/token";
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("grant_type" , "authorization_code");
ПараметрыURL.Вставить("client_id" , ClientID);
ПараметрыURL.Вставить("client_secret", ClientSecret);
ПараметрыURL.Вставить("redirect_uri" , "http://localhost");
ПараметрыURL.Вставить("redirect_uri" , "http://localhost");
ПараметрыURL.Вставить("code" , Code);
Ответ = OPI_Инструменты.Post(URL, ПараметрыURL, , Ложь);
Возврат Ответ;
КонецФункции
// Обновить токен
// Обновляет токен по Refresh token
//
//
// Параметры:
// ClientID - Строка - Client ID - id
// ClientSecret - Строка - Client secret - secret
// RefreshToken - Строка - Refresh token - refresh
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ОбновитьТокен(Знач ClientID, Знач ClientSecret, Знач RefreshToken) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientID);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientSecret);
OPI_ПреобразованиеТипов.ПолучитьСтроку(RefreshToken);
URL = "https://accounts.google.com/o/oauth2/token";
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("grant_type" , "refresh_token");
ПараметрыURL.Вставить("client_id" , ClientID);
ПараметрыURL.Вставить("client_secret", ClientSecret);
ПараметрыURL.Вставить("client_secret", ClientSecret);
ПараметрыURL.Вставить("refresh_token", RefreshToken);
Ответ = OPI_Инструменты.Post(URL, ПараметрыURL, , Ложь);
Возврат Ответ;
КонецФункции
@ -141,14 +141,14 @@
#Область СлужебныйПрограммныйИнтерфейс
Функция ПолучитьЗаголовокАвторизации(Знач Токен) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
Заголовки = Новый Соответствие;
Заголовки.Вставить("Authorization", "Bearer " + Токен);
Возврат Заголовки;
КонецФункции
#КонецОбласти
@ -156,23 +156,23 @@
#Область СлужебныеПроцедурыИфункции
Функция ПолучитьСписокРазрешений(Calendar, Drive, Sheets)
МассивРазрешений = Новый Массив;
Если Calendar Тогда
МассивРазрешений.Добавить("https://www.googleapis.com/auth/calendar");
КонецЕсли;
Если Drive Тогда
МассивРазрешений.Добавить("https://www.googleapis.com/auth/drive");
КонецЕсли;
Если Sheets Тогда
МассивРазрешений.Добавить("https://www.googleapis.com/auth/spreadsheets");
КонецЕсли;
Возврат СтрСоединить(МассивРазрешений, " ");
КонецФункции
#КонецОбласти

510
src/ru/OInt/core/Modules/OPI_Notion.os
View File

File diff suppressed because it is too large Load Diff

496
src/ru/OInt/core/Modules/OPI_Slack.os
View File

File diff suppressed because it is too large Load Diff

490
src/ru/OInt/core/Modules/OPI_Telegram.os
View File

File diff suppressed because it is too large Load Diff

406
src/ru/OInt/core/Modules/OPI_Twitter.os
View File

@ -48,18 +48,18 @@
// Получить ссылку для авторизации
// Формирует ссылку для авторизации через браузер
//
//
// Параметры:
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Строка - URL для перехода в браузере
Функция ПолучитьСсылкуАвторизации(Параметры = "") Экспорт
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("response_type" , "code");
ПараметрыURL.Вставить("client_id" , Параметры_["client_id"]);
ПараметрыURL.Вставить("redirect_uri" , Параметры_["redirect_uri"]);
@ -67,27 +67,27 @@
ПараметрыURL.Вставить("state" , "state");
ПараметрыURL.Вставить("code_challenge" , "challenge");
ПараметрыURL.Вставить("code_challenge_method", "plain");
ПараметрыURL = OPI_Инструменты.ПараметрыЗапросаВСтроку(ПараметрыURL);
Линк = "https://twitter.com/i/oauth2/authorize" + ПараметрыURL;
Линк = "https://twitter.com/i/oauth2/authorize" + ПараметрыURL;
Возврат Линк;
КонецФункции
// Получить токен
// Получает токен по коду, полученному при авторизации по ссылке из ПолучитьСсылкуАвторизации
//
//
// Параметры:
// Код - Строка - Код, полученный из авторизации См.ПолучитьСсылкуАвторизации - code
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция ПолучитьТокен(Знач Код, Знач Параметры = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Код);
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
ПараметрыЗапроса = Новый Структура;
@ -96,35 +96,35 @@
ПараметрыЗапроса.Вставить("client_id" , Параметры_["client_id"]);
ПараметрыЗапроса.Вставить("redirect_uri" , Параметры_["redirect_uri"]);
ПараметрыЗапроса.Вставить("code_verifier", "challenge");
Ответ = OPI_Инструменты.Post("https://api.twitter.com/2/oauth2/token"
, ПараметрыЗапроса, , Ложь);
Возврат Ответ;
КонецФункции
// Обновить токен
// Обновить токен
// Обновляет v2 токен при помощи refresh_token
//
//
// Параметры:
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция ОбновитьТокен(Знач Параметры = "") Экспорт
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
Refresh = "refresh_token";
ПараметрыЗапроса = Новый Структура;
ПараметрыЗапроса.Вставить(Refresh , Параметры_[Refresh]);
ПараметрыЗапроса.Вставить("grant_type" , Refresh);
ПараметрыЗапроса.Вставить("client_id" , Параметры_["client_id"]);
Ответ = OPI_Инструменты.Post("https://api.twitter.com/2/oauth2/token"
, ПараметрыЗапроса, , Ложь);
Возврат Ответ;
КонецФункции
@ -133,23 +133,23 @@
// Метод для вставки в http-сервис, адрес которого указывается в redirect_uri
// Вызывает метод получения токена, так как для получения токена из кода, приходящего
// на redirect_uri после авторизации через браузер есть всего 30 секунд
//
//
// Параметры:
// Запрос - HTTPСервисЗапрос - Запрос, приходящий на http-сервис
//
//
// Возвращаемое значение:
// HTTPОтвет, Произвольный, ДвоичныеДанные - Результат чтения JSON ответа сервера
Функция ОбработкаВходящегоЗапросаПослеАвторизации(Запрос) Экспорт
Код = Запрос.ПараметрыЗапроса["code"];
Код = Запрос.ПараметрыЗапроса["code"];
ОтветТокен = ПолучитьТокен(Код);
// BSLLS:CommentedCode-off
// Предпочтительное хранение токенов
// Константы.TwitterRefresh.Установить(ОтветТокен["refresh_token"]);
// Константы.TwitterToken.Установить(ОтветТокен["access_token"]);
// BSLLS:CommentedCode-on
Возврат ОтветТокен;
КонецФункции
@ -160,189 +160,189 @@
// !NOCLI
// Создать произвольный твит
//
//
// Параметры:
// Текст - Строка - Текст твита
// МассивМедиа - Массив из Строка,ДвоичныеДанные - Массив двоичных данных или путей к файлам
// МассивВариантовОпроса - Массив из Строка - Массив вариантов опроса, если необходимо
// ДлительностьОпроса - Строка,Число - Длительность опроса, если необходимо (опрос без длительности не создается)
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьПроизвольныйТвит(Знач Текст = ""
, Знач МассивМедиа = ""
, Знач МассивВариантовОпроса = ""
, Знач ДлительностьОпроса = ""
, Знач Параметры = "") Экспорт
, Знач Параметры = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Текст);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ДлительностьОпроса);
Если ЗначениеЗаполнено(МассивМедиа) Тогда
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивМедиа);
КонецЕсли;
Если ЗначениеЗаполнено(МассивВариантовОпроса) Тогда
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивВариантовОпроса);
КонецЕсли;
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
URL = "https://api.twitter.com/2/tweets";
Массив = "Массив";
Массив = "Массив";
Поля = Новый Соответствие;
Если ЗначениеЗаполнено(Текст) Тогда
Поля.Вставить("text", Текст);
КонецЕсли;
Если ТипЗнч(МассивВариантовОпроса) = Тип(Массив) И ЗначениеЗаполнено(ДлительностьОпроса) Тогда
ДлительностьОпроса = Число(ДлительностьОпроса);
Если МассивВариантовОпроса.Количество() > 0 Тогда
СтруктураВарианта = Новый Структура("options,duration_minutes", МассивВариантовОпроса, ДлительностьОпроса);
Поля.Вставить("poll", СтруктураВарианта);
КонецЕсли;
КонецЕсли;
Если ТипЗнч(МассивМедиа) = Тип(Массив) Тогда
Если МассивМедиа.Количество() > 0 Тогда
Поля.Вставить("media", Новый Структура("media_ids", МассивМедиа));
КонецЕсли;
КонецЕсли;
Авторизация = СоздатьЗаголовокАвторизацииV2(Параметры_);
Ответ = OPI_Инструменты.Post(URL, Поля, Авторизация);
Возврат Ответ;
КонецФункции
// Создать текстовый твит
// Создает твит без вложений
//
//
// Параметры:
// Текст - Строка - Текст твита - text
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьТекстовыйТвит(Знач Текст, Знач Параметры = "") Экспорт
Возврат СоздатьПроизвольныйТвит(Текст, , , , Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, , , , Параметры);
КонецФункции
// Создать твит картинки
// Создает твит с картинкой вложением
//
//
// Параметры:
// Текст - Строка - Текст твита - text
// МассивКартинок - Массив из Строка,ДвоичныеДанные - Массив файлов картинок - pictures
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьТвитКартинки(Знач Текст, Знач МассивКартинок, Знач Параметры = "") Экспорт
МассивМедиа = ЗагрузитьМассивВложений(МассивКартинок, "photo", Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, МассивМедиа, , , Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, МассивМедиа, , , Параметры);
КонецФункции
// Создать твит гифки
// Создает твит с вложением-гифкой
//
//
// Параметры:
// Текст - Строка - Текст твита - text
// МассивГифок - Массив из Строка,ДвоичныеДанные - Массив файлов гифок - gifs
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьТвитГифки(Знач Текст, Знач МассивГифок, Знач Параметры = "") Экспорт
МассивМедиа = ЗагрузитьМассивВложений(МассивГифок, "animated_gif", Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, МассивМедиа, , , Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, МассивМедиа, , , Параметры);
КонецФункции
// Создать твит видео
// Создает твит с видеовложением
//
//
// Параметры:
// Текст - Строка - Текст твита - text
// МассивВидео - Массив из Строка,ДвоичныеДанные - Массив файлов видео - videos
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьТвитВидео(Знач Текст, Знач МассивВидео, Знач Параметры = "") Экспорт
МассивМедиа = ЗагрузитьМассивВложений(МассивВидео, "video", Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, МассивМедиа, , , Параметры);
КонецФункции
// Создать твит опрос
// Создает твит с опросом
//
//
// Параметры:
// Текст - Строка - Текст твита - text
// МассивВариантов - Массив из Строка - Массив вариантов опроса - options
// Длительность - Строка,Число - Длительность опроса - duration
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьТвитОпрос(Знач Текст, Знач МассивВариантов, Знач Длительность, Знач Параметры = "") Экспорт
Возврат СоздатьПроизвольныйТвит(Текст, , МассивВариантов, Длительность, Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, , МассивВариантов, Длительность, Параметры);
КонецФункции
// Загрузить массив вложений !NOCLI
// Загружает файлы на сервер и возвращает их ID
//
//
// Параметры:
// МассивФайлов - Массив из Строка, ДвоичныеДанные - Массив файлов
// ТипВложений - Строка - Тип вложений
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Массив Из Строка - Массив ID медиа
Функция ЗагрузитьМассивВложений(Знач МассивФайлов, Знач ТипВложений, Знач Параметры = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ТипВложений);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивФайлов);
МассивМедиа = Новый Массив;
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
MIS = "media_id_string";
Если ЗначениеЗаполнено(МассивФайлов) Тогда
Для Каждого ФайлОтправки Из МассивФайлов Цикл
OPI_ПреобразованиеТипов.ПолучитьДвоичныеДанные(ФайлОтправки);
Ответ = ЗагрузитьМедиафайл(ФайлОтправки, ТипВложений, Параметры_);
IDМедиа = Ответ[MIS];
Если Не ЗначениеЗаполнено(IDМедиа) Тогда
Возврат Ответ;
КонецЕсли;
МассивМедиа.Добавить(IDМедиа);
КонецЦикла;
КонецЕсли;
Возврат МассивМедиа;
КонецФункции
#КонецОбласти
@ -351,70 +351,70 @@
#Область СлужебныеПроцедурыИФункции
Функция ЗагрузитьМедиафайл(Знач Файл, Знач Тип, Знач Параметры)
Функция ЗагрузитьМедиафайл(Знач Файл, Знач Тип, Знач Параметры)
OPI_ПреобразованиеТипов.ПолучитьДвоичныеДанные(Файл);
ВидЗапроса = "POST";
ВидЗапроса = "POST";
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
URL = "https://upload.twitter.com/1.1/media/upload.json";
Если Тип = "photo" Тогда
Если Тип = "photo" Тогда
Поля = Новый Структура;
Поля.Вставить("media_data" , Base64Строка(Файл));
Поля.Вставить("media_category", Тип);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры_, Поля, ВидЗапроса, URL);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры_, Поля, ВидЗапроса, URL);
Ответ = OPI_Инструменты.Post(URL, Поля, Авторизация, Ложь);
Иначе
Ответ = ЗагрузитьМедиаЧастями(Файл, Тип, ВидЗапроса, URL, Параметры_);
КонецЕсли;
Возврат Ответ;
КонецФункции
Функция ЗагрузитьМедиаЧастями(Знач Файл, Знач Тип, Знач ВидЗапроса, Знач URL, Параметры)
Единица = 1024;
Количество = 4;
MediaKey = "media_key";
MIS = "media_id_string";
Command = "command";
Размер = Файл.Размер();
СоответствиеMIME = Новый Соответствие;
СоответствиеMIME.Вставить("photo" , "image/jpeg");
СоответствиеMIME.Вставить("video" , "video/mp4");
СоответствиеMIME.Вставить("animated_gif", "image/gif");
РазмерЧасти = Количество * Единица * Единица;
МассивЧтения = РазделитьДвоичныеДанные(Файл, РазмерЧасти);
Поля = Новый Структура;
Поля.Вставить(Command , "INIT");
Поля.Вставить("total_bytes" , OPI_Инструменты.ЧислоВСтроку(Размер));
Поля.Вставить("media_type" , СоответствиеMIME.Получить(Тип));
Поля.Вставить("media_category" , Тип);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Поля, ВидЗапроса, URL);
ОтветИнициализации = OPI_Инструменты.Post(URL, Поля, Авторизация, Ложь);
KeyИнициализации = ОтветИнициализации[MediaKey];
IDИнициализации = ОтветИнициализации[MIS];
Если Не ЗначениеЗаполнено(KeyИнициализации) Или Не ЗначениеЗаполнено(IDИнициализации) Тогда
Возврат ОтветИнициализации;
Возврат ОтветИнициализации;
КонецЕсли;
Счетчик = 0;
Для Каждого Часть Из МассивЧтения Цикл
Поля = Новый Структура;
Поля.Вставить(Command , "APPEND");
Поля.Вставить("media_key" , KeyИнициализации);
@ -422,111 +422,111 @@
Поля.Вставить("media" , Часть);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Новый Структура, ВидЗапроса, URL);
OPI_Инструменты.PostMultipart(URL, Поля, , , Авторизация);
Счетчик = Счетчик + 1;
КонецЦикла;
Поля = Новый Структура;
Поля.Вставить(Command , "FINALIZE");
Поля.Вставить("media_id", IDИнициализации);
СтатусОбработки = ПолучитьСтатусОбработки(Параметры, Поля, URL);
Если Не ТипЗнч(СтатусОбработки) = Тип("Строка") Тогда
Возврат СтатусОбработки;
КонецЕсли;
Ответ = ОжидатьЗавершенияОбработки(СтатусОбработки, IDИнициализации, URL, Параметры);
Возврат Ответ;
КонецФункции
Функция ОжидатьЗавершенияОбработки(Знач СтатусОбработки, Знач IDИнициализации, Знач URL, Знач Параметры)
ProcessingInfo = "processing_info";
Command = "command";
Поля = Новый Структура;
Поля.Вставить(Command , "STATUS");
Поля.Вставить("media_id", IDИнициализации);
Пока Строка(СтатусОбработки) = "pending" Или Строка(СтатусОбработки) = "in_progress" Цикл
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Поля, "GET", URL);
Ответ = OPI_Инструменты.Get(URL, Поля, Авторизация);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Поля, "GET", URL);
Ответ = OPI_Инструменты.Get(URL, Поля, Авторизация);
Информация = Ответ[ProcessingInfo];
Если Не ЗначениеЗаполнено(Информация) Тогда
Возврат Ответ;
КонецЕсли;
СтатусОбработки = Информация["state"];
Если Не ЗначениеЗаполнено(СтатусОбработки) Тогда
Возврат Ответ;
КонецЕсли;
КонецЦикла;
Если СтатусОбработки = "failed" Тогда
ВызватьИсключение "Твиттер не смог обработать загруженное вами видео";
КонецЕсли;
Возврат Ответ;
КонецФункции
Функция ПолучитьСтандартныеПараметры(Знач Параметры = "")
// Здесь собрано определение данных, необходимых для работы.
// Для Twitter это довольно значительный набор, что обсуловлено наличием сразу 2-х API,
// которые, при этом, созданы не для разныз задач, но просто являются версиями друг друга.
// Актуальной версией API является v2 и она требует получения временных токенов. Несмотря на то,
// что Twitter настаивает на использовании этой актуальной версии, они как-то умудрились не перенести
// механизм загрузки файлов и некоторые другие из старой версии - v1.1. Поэтому что-то нужно делать
// механизм загрузки файлов и некоторые другие из старой версии - v1.1. Поэтому что-то нужно делать
// на версии 1.1, а что-то на 2: вплоть до того что они убрали возможность постить твиты из v1.1,
// но только через нее в твит можно добавить картинку. При этом способы авторизации и токены у них разные
// Мировая гигокорпорация Илона Маска, кстати, напоминаю ;)
// P.S Далее часто упоминается "страница настроек Twitter Developer" - это
// P.S Далее часто упоминается "страница настроек Twitter Developer" - это
// https://developer.twitter.com/en/portal/dashboard и выбор конкретного проекта из списка (значек c ключем)
Параметры_ = Новый Соответствие;
Параметры_ = Новый Соответствие;
Разрешения = "tweet.read tweet.write tweet.moderate.write users.read "
+ "follows.read follows.write offline.access space.read mute.read "
+ "mute.write like.read like.write list.read list.write block.read "
+ "block.write bookmark.read bookmark.write";
+ "block.write bookmark.read bookmark.write";
// Данные для API v2
// redirect_uri - URL вашего http-сервиса (или другого обработчика запросов) для авторизации
// scope - набор разрешений для получаемого ключа. Может быть любой, но offline.access обязателен
// client_id - Из OAuth 2.0 Client ID and Client Secret страницы настроек Twitter Developer
// client_secret - Из OAuth 2.0 Client ID and Client Secret страницы настроек Twitter Developer
// access_token - ПолучитьСсылкуАвторизации() -> Браузер -> code придет на redirect_uri -> ПолучитьТокен(code)
// refresh_token - Приходит вместе с access_token и используется для его обновления (время жизни access_token - 2 ч)
// Обновление происходит методом ОбновитьТокен с новыми access_token и refresh_token.
// При следующем обновлении нужно использовать уже новый refresh_token, так что захардкодить
// не получится (access_token тоже не получится)
// Обновление происходит методом ОбновитьТокен с новыми access_token и refresh_token.
// При следующем обновлении нужно использовать уже новый refresh_token, так что захардкодить
// не получится (access_token тоже не получится)
// |--> ОбновитьТокен() ->|access_token --> Используется в т-нии 2-х часов для запросов
// | |refresh_token --|
// |--------[через 2 ч.]-------------------|
// Данные для API v1.1
// oauth_token - Из Authentication Tokens -> Access Token and Secret страницы настроек Twitter Developer
// oauth_token - Из Authentication Tokens -> Access Token and Secret страницы настроек Twitter Developer
// oauth_token_secret - Из Authentication Tokens -> Access Token and Secret страницы настроек Twitter Developer
// oauth_consumer_key - Из Consumer Keys -> Access Token and Secret страницы настроек Twitter Developer
// oauth_consumer_secret - Из Consumer Keys -> Access Token and Secret страницы настроек Twitter Developer
// Эти токены обновлять не надо
Параметры_.Вставить("redirect_uri" , "");
Параметры_.Вставить("scope" , Разрешения);
Параметры_.Вставить("client_id" , "");
@ -537,9 +537,9 @@
Параметры_.Вставить("oauth_token_secret" , "");
Параметры_.Вставить("oauth_consumer_key" , "");
Параметры_.Вставить("oauth_consumer_secret", "");
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(Параметры);
Если ТипЗнч(Параметры) = Тип("Структура") Или ТипЗнч(Параметры) = Тип("Соответствие") Тогда
Для Каждого ПереданныйПараметр Из Параметры Цикл
Параметры_.Вставить(ПереданныйПараметр.Ключ, OPI_Инструменты.ЧислоВСтроку(ПереданныйПараметр.Значение));
@ -551,7 +551,7 @@
КонецФункции
Функция СоздатьЗаголовокАвторизацииV1(Знач Параметры, Знач Поля, Знач ВидЗапроса, Знач URL)
ТекущаяДата = OPI_Инструменты.ПолучитьТекущуюДату();
ЗаголовокАвторизации = "";
МетодХэширования = "HMAC-SHA1";
@ -565,123 +565,123 @@
ТаблицаПараметров = Новый ТаблицаЗначений;
ТаблицаПараметров.Колонки.Добавить("Ключ");
ТаблицаПараметров.Колонки.Добавить("Значение");
Для Каждого Поле Из Поля Цикл
НоваяСтрока = ТаблицаПараметров.Добавить();
Для Каждого Поле Из Поля Цикл
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = Поле.Ключ;
НоваяСтрока.Значение = Поле.Значение;
КонецЦикла;
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = OCK;
НоваяСтрока.Значение = Параметры[OCK];
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = OTK;
НоваяСтрока.Значение = Параметры[OTK];
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = "oauth_version";
НоваяСтрока.Значение = ВерсияАпи;
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = "oauth_signature_method";
НоваяСтрока.Значение = МетодХэширования;
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = "oauth_timestamp";
НоваяСтрока.Значение = ТекущаяДатаUNIX;
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = "oauth_nonce";
НоваяСтрока.Значение = ТекущаяДатаUNIX;
Для Каждого СтрокаТаблицы Из ТаблицаПараметров Цикл
СтрокаТаблицы.Ключ = КодироватьСтроку(СтрокаТаблицы.Ключ, СпособКодированияСтроки.КодировкаURL);
СтрокаТаблицы.Значение = КодироватьСтроку(СтрокаТаблицы.Значение, СпособКодированияСтроки.КодировкаURL);
КонецЦикла;
ТаблицаПараметров.Сортировать("Ключ");
Для Каждого СтрокаТаблицы Из ТаблицаПараметров Цикл
СтрокаСигнатуры = СтрокаСигнатуры
+ СтрокаТаблицы.Ключ
+ "="
СтрокаСигнатуры = СтрокаСигнатуры
+ СтрокаТаблицы.Ключ
+ " ="
+ СтрокаТаблицы.Значение
+ "&";
КонецЦикла;
СтрокаСигнатуры = Лев(СтрокаСигнатуры, СтрДлина(СтрокаСигнатуры) - 1);
СтрокаСигнатуры = вРег(ВидЗапроса)
+ "&"
+ КодироватьСтроку(URL, СпособКодированияСтроки.КодировкаURL)
СтрокаСигнатуры = вРег(ВидЗапроса)
+ "&"
+ КодироватьСтроку(URL , СпособКодированияСтроки.КодировкаURL)
+ "&"
+ КодироватьСтроку(СтрокаСигнатуры, СпособКодированияСтроки.КодировкаURL);
Подпись = КодироватьСтроку(Параметры["oauth_consumer_secret"], СпособКодированияСтроки.КодировкаURL)
+ "&"
+ "&"
+ КодироватьСтроку(Параметры["oauth_token_secret"], СпособКодированияСтроки.КодировкаURL);
Сигнатура = OPI_Криптография.HMAC(ПолучитьДвоичныеДанныеИзСтроки(Подпись)
, ПолучитьДвоичныеДанныеИзСтроки(СтрокаСигнатуры)
, ХешФункция.SHA1
, 64);
Сигнатура = КодироватьСтроку(Base64Строка(Сигнатура), СпособКодированияСтроки.КодировкаURL);
Разделитель = """,";
ЗаголовокАвторизации = ЗаголовокАвторизации
Разделитель = """,";
ЗаголовокАвторизации = ЗаголовокАвторизации
+ "OAuth "
+ "oauth_consumer_key=""" + Параметры[OCK] + Разделитель
+ "oauth_token=""" + Параметры[OTK] + Разделитель
+ "oauth_consumer_key =""" + Параметры[OCK] + Разделитель
+ "oauth_token =""" + Параметры[OTK] + Разделитель
+ "oauth_signature_method=""" + МетодХэширования + Разделитель
+ "oauth_timestamp=""" + ТекущаяДатаUNIX + Разделитель
+ "oauth_nonce=""" + ТекущаяДатаUNIX + Разделитель
+ "oauth_version=""" + ВерсияАпи + Разделитель
+ "oauth_signature=""" + Сигнатура;
+ "oauth_timestamp =""" + ТекущаяДатаUNIX + Разделитель
+ "oauth_nonce =""" + ТекущаяДатаUNIX + Разделитель
+ "oauth_version =""" + ВерсияАпи + Разделитель
+ "oauth_signature =""" + Сигнатура;
СоответствиеЗаголовка = Новый Соответствие;
СоответствиеЗаголовка.Вставить("authorization", ЗаголовокАвторизации);
Возврат СоответствиеЗаголовка;
КонецФункции
Функция СоздатьЗаголовокАвторизацииV2(Знач Параметры)
СоответствиеВозврата = Новый Соответствие;
СоответствиеВозврата.Вставить("Authorization", "Bearer " + Параметры["access_token"]);
Возврат СоответствиеВозврата;
КонецФункции
Функция ПолучитьСтатусОбработки(Знач Параметры, Знач Поля, Знач URL)
ProcessingInfo = "processing_info";
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Поля, "POST", URL);
Ответ = OPI_Инструменты.Post(URL, Поля, Авторизация, Ложь);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Поля, "POST", URL);
Ответ = OPI_Инструменты.Post(URL, Поля, Авторизация, Ложь);
Информация = Ответ[ProcessingInfo];
Если Не ЗначениеЗаполнено(Информация) Тогда
Возврат Ответ;
КонецЕсли;
СтатусОбработки = Информация["state"];
Если Не ЗначениеЗаполнено(СтатусОбработки) Тогда
Возврат Ответ;
Иначе
Возврат СтатусОбработки;
КонецЕсли;
КонецЕсли;
КонецФункции
#КонецОбласти

1250
src/ru/OInt/core/Modules/OPI_VK.os
View File

File diff suppressed because it is too large Load Diff

200
src/ru/OInt/core/Modules/OPI_Viber.os
View File

@ -23,7 +23,7 @@
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
// https://github.com/Bayselonarrend/OpenIntegrations
// BSLLS:LatinAndCyrillicSymbolInWord-off
@ -46,55 +46,55 @@
// который будет возвращать 200 и подлинный SSL сертификат. Если есть сертификат и база опубликована
// на сервере - можно использовать http-сервис. Туда же будет приходить и информация о новых сообщениях
// Viber периодически стучит по адресу Webhook, так что если он будет неактивен, то все перестанет работать
//
//
// Параметры:
// Токен - Строка - Токен Viber - token
// URL - Строка - URL для установки Webhook - url
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция УстановитьWebhook(Знач Токен, Знач URL) Экспорт
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("url" , URL , "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("auth_token" , Токен, "Строка", Параметры);
Возврат OPI_Инструменты.Post("https://chatapi.viber.com/pa/set_webhook", Параметры);
КонецФункции
// Получить информацию о канале
// Тут можно получить ID пользователей канала. ID для бота необходимо получать из прилетов на Webhook
// ID пользователя из информации о канале не подойдет для отправки сообщений через бота - они разные
//
//
// Параметры:
// Токен - Строка - Токен - token
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ПолучитьИнформациюОКанале(Знач Токен) Экспорт
URL = "https://chatapi.viber.com/pa/get_account_info";
URL = "https://chatapi.viber.com/pa/get_account_info";
Возврат OPI_Инструменты.Get(URL, , ТокенВЗаголовки(Токен));
КонецФункции
// Получить данные пользователя
// Получает информацию о пользователе по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// IDПользователя - Строка, Число - ID пользователя Viber - user
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ПолучитьДанныеПользователя(Знач Токен, Знач IDПользователя) Экспорт
URL = "https://chatapi.viber.com/pa/get_user_details";
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("id", IDПользователя, "Строка", Параметры);
Ответ = OPI_Инструменты.Post(URL, Параметры, ТокенВЗаголовки(Токен));
Возврат Ответ;
@ -103,22 +103,22 @@
// Получить онлайн пользователей
// Получает статус пользователя или нескольких пользователей по ID
//
//
// Параметры:
// Токен - Строка - Токен Viber - token
// IDПользователей - Строка,Число,Массив из Строка,Число - ID пользователей(я) Viber - users
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ПолучитьОнлайнПользователей(Знач Токен, Знач IDПользователей) Экспорт
URL = "https://chatapi.viber.com/pa/get_online";
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("ids", IDПользователей, "Коллекция", Параметры);
Ответ = OPI_Инструменты.Post(URL, Параметры, ТокенВЗаголовки(Токен));
Возврат Ответ;
КонецФункции
@ -129,14 +129,14 @@
// Отправить текстовое сообщение
// Отправляет текстовое сообщение в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// Текст - Строка - Текст сообщения - text
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - Булево - Отправка в канал или в чат бота - ischannel
// Клавиатура - Структура из Строка - См. СформироватьКлавиатуруИзМассиваКнопок - keyboard
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьТекстовоеСообщение(Знач Токен
@ -144,40 +144,40 @@
, Знач IDПользователя
, Знач ОтправкаВКанал
, Знач Клавиатура = "") Экспорт
Возврат ОтправитьСообщение(Токен, "text", IDПользователя, ОтправкаВКанал, , Текст, Клавиатура);
Возврат ОтправитьСообщение(Токен, "text", IDПользователя, ОтправкаВКанал, , Текст, Клавиатура);
КонецФункции
// Отправить картинку
// Отправляет картинку в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - URL картинки - picture
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - булево - Отправка в канал или в чат бота - ischannel
// Описание - Строка - Аннотация к картинке - description
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьКартинку(Знач Токен, Знач URL, Знач IDПользователя, Знач ОтправкаВКанал, Знач Описание = "") Экспорт
Возврат ОтправитьСообщение(Токен, "picture", IDПользователя, ОтправкаВКанал, URL, Описание);
КонецФункции
// Отправить файл
// Отправляет файл (документ) в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - URL файла - file
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// URL - Строка - URL файла - file
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - Булево - Отправка в канал или в чат бота - ischannel
// Расширение - Строка - Расширение файла - ext
// Размер - Число - Размер файла. Если не заполнен > определяется автоматически скачиванием файла - size
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьФайл(Знач Токен
@ -186,36 +186,36 @@
, Знач ОтправкаВКанал
, Знач Расширение
, Знач Размер = "") Экспорт
Если Не ЗначениеЗаполнено(Размер) Тогда
Ответ = OPI_Инструменты.Get(URL);
Размер = Ответ.Размер();
КонецЕсли;
Строка_ = "Строка";
Расширение = СтрЗаменить(Расширение, ".", "");
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("URL" , URL , Строка_, Параметры);
OPI_Инструменты.ДобавитьПоле("Размер" , Размер , Строка_, Параметры);
OPI_Инструменты.ДобавитьПоле("Расширение", Расширение, Строка_, Параметры);
Возврат ОтправитьСообщение(Токен, "file", IDПользователя, ОтправкаВКанал, Параметры);
КонецФункции
// Отправить контакт
// Отправляет контакт с номером телефона в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИмяКонтакта - Строка - Имя контакта - name
// НомерТелефона - Строка - Номер телефона - phone
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - Булево - Отправка в канал или в чат бота - ischannel
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьКонтакт(Знач Токен
@ -223,91 +223,91 @@
, Знач НомерТелефона
, Знач IDПользователя
, Знач ОтправкаВКанал) Экспорт
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("name" , ИмяКонтакта , "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("phone_number", НомерТелефона, "Строка", Параметры);
Возврат ОтправитьСообщение(Токен, "contact", IDПользователя, ОтправкаВКанал, Параметры);
Возврат ОтправитьСообщение(Токен, "contact", IDПользователя, ОтправкаВКанал, Параметры);
КонецФункции
// Отправить локацию
// Отправляет географические координаты в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// Широта - Строка,Число - Географическая широта - lat
// Долгота - Строка,Число - Географическая долгота - long
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - Булево - Отправка в канал или в чат бота - ischannel
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьЛокацию(Знач Токен, Знач Широта, Знач Долгота, Знач IDПользователя, Знач ОтправкаВКанал) Экспорт
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("lat", Широта , "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("lon", Долгота, "Строка", Параметры);
Возврат ОтправитьСообщение(Токен, "location", IDПользователя, ОтправкаВКанал, Параметры);
КонецФункции
// Отправить ссылку
// Отправляет URL с предпросмотром в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - Отправляемая ссылка - url
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - Булево - Отправка в канал или в чат бота - ischannel
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьСсылку(Знач Токен, Знач URL, Знач IDПользователя, Знач ОтправкаВКанал) Экспорт
Возврат ОтправитьСообщение(Токен, "url", IDПользователя, ОтправкаВКанал, URL);
КонецФункции
// Сформировать клавиатуру из массива кнопок
// Возвращает структура клавиатуры для сообщений
//
//
// Параметры:
// МассивКнопок - Массив из Строка - Массив кнопок - buttons
// ЦветКнопок - Строка - HEX цвет кнопок с # в начале - color
//
//
// Возвращаемое значение:
// Структура - Сформировать клавиатуру из массива кнопок:
// * Buttons - Массив из Структура - Массив сформированных кнопок
// * Type - Строка - Тип клавиатуры
// * Buttons - Массив из Структура - Массив сформированных кнопок
// * Type - Строка - Тип клавиатуры
Функция СформироватьКлавиатуруИзМассиваКнопок(Знач МассивКнопок, Знач ЦветКнопок = "#2db9b9") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ЦветКнопок);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивКнопок);
МассивСтруктурКнопок = Новый Массив;
СтруктураКлавиатуры = Новый Структура;
Для Каждого ТекстКнопки Из МассивКнопок Цикл
СтруктураКнопки = Новый Структура;
СтруктураКнопки.Вставить("ActionType", "reply");
СтруктураКнопки.Вставить("ActionBody", ТекстКнопки);
СтруктураКнопки.Вставить("Text" , ТекстКнопки);
СтруктураКнопки.Вставить("BgColor" , ЦветКнопок);
СтруктураКнопки.Вставить("Coloumns" , 3);
МассивСтруктурКнопок.Добавить(СтруктураКнопки);
КонецЦикла;
СтруктураКлавиатуры.Вставить("Buttons", МассивСтруктурКнопок);
СтруктураКлавиатуры.Вставить("Type" , "keyboard");
Возврат СтруктураКлавиатуры;
КонецФункции
#КонецОбласти
@ -317,7 +317,7 @@
#Область СлужебныеПроцедурыИФункции
// Отправить сообщение.
//
//
// Параметры:
// Токен - Строка - Токен
// Тип - Строка - Тип отправляемого сообщения
@ -328,8 +328,8 @@
// * Размер - Число, Строка - Размер файла в случае отправке
// * Расширение - Строка - Расширение файла в случае отправки
// Текст - Строка - Текст сообщения
// Клавиатура - Структура из Строка - Клавиатура, если нужна, см. СформироватьКлавиатуруИзМассиваКнопок
//
// Клавиатура - Структура из Строка - Клавиатура, если нужна, см. СформироватьКлавиатуруИзМассиваКнопок
//
// Возвращаемое значение:
// Произвольный, HTTPОтвет - Отправить сообщение
Функция ОтправитьСообщение(Знач Токен
@ -339,28 +339,28 @@
, Знач Значение = ""
, Знач Текст = ""
, Знач Клавиатура = "")
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Тип);
OPI_ПреобразованиеТипов.ПолучитьСтроку(IDПользователя);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Текст);
OPI_ПреобразованиеТипов.ПолучитьБулево(ЭтоКанал);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(Клавиатура);
СтруктураПараметров = ВернутьСтандартныеПараметры();
СтруктураПараметров.Вставить("type", Тип);
СтруктураПараметров.Вставить("type", Тип);
Если (Тип = "text" Или Тип = "picture") И ЗначениеЗаполнено(Текст) Тогда
СтруктураПараметров.Вставить("text", Текст);
КонецЕсли;
Если ТипЗнч(Клавиатура) = Тип("Структура") Тогда
СтруктураПараметров.Вставить("keyboard", Клавиатура);
КонецЕсли;
Если ЗначениеЗаполнено(Значение) Тогда
Если Тип = "file" Тогда
Если Тип = "file" Тогда
СтруктураПараметров.Вставить("media" , Значение["URL"]);
СтруктураПараметров.Вставить("size" , Значение["Размер"]);
СтруктураПараметров.Вставить("file_name", "Файл." + Значение["Расширение"]);
@ -371,49 +371,49 @@
Иначе
СтруктураПараметров.Вставить("media" , Значение);
КонецЕсли;
КонецЕсли;
Если ЭтоКанал Тогда
СтруктураПараметров.Вставить("from", IDПользователя);
СтруктураПараметров.Вставить("from" , IDПользователя);
URL = "https://chatapi.viber.com/pa/post";
Иначе
Иначе
СтруктураПараметров.Вставить("receiver", IDПользователя);
URL = "https://chatapi.viber.com/pa/send_message";
КонецЕсли;
Ответ = OPI_Инструменты.Post(URL, СтруктураПараметров, ТокенВЗаголовки(Токен));
Попытка
Возврат OPI_Инструменты.JsonВСтруктуру(Ответ.ПолучитьТелоКакДвоичныеДанные());
Исключение
Возврат Ответ;
КонецПопытки;
КонецФункции
Функция ВернутьСтандартныеПараметры()
Функция ВернутьСтандартныеПараметры()
СтруктураОтправителя = Новый Структура;
СтруктураОтправителя.Вставить("name" , "Bot");
СтруктураОтправителя.Вставить("avatar", "");
СтруктураПараметров = Новый Структура;
СтруктураПараметров.Вставить("sender", СтруктураОтправителя);
СтруктураПараметров.Вставить("sender" , СтруктураОтправителя);
СтруктураПараметров.Вставить("min_api_version", 1);
Возврат СтруктураПараметров;
КонецФункции
Функция ТокенВЗаголовки(Знач Токен)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
СтруктураЗаголовков = Новый Соответствие;
СтруктураЗаголовков.Вставить("X-Viber-Auth-Token", Токен);
Возврат СтруктураЗаголовков;
КонецФункции
#КонецОбласти

380
src/ru/OInt/core/Modules/OPI_YandexDisk.os
View File

@ -37,7 +37,7 @@
//@skip-check wrong-string-literal-content
// Раскомментировать, если выполняется OneScript
#Использовать "../../tools"
#Использовать "../../tools"
#Область ПрограммныйИнтерфейс
@ -45,217 +45,217 @@
// Получить информацию о диске
// Получает информацию о текущем диске
//
//
// Параметры:
// Токен - Строка - Токен - token
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьИнформациюОДиске(Знач Токен) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
Заголовки = ЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk", , Заголовки);
Возврат Ответ;
КонецФункции
// Создать папку
// Создает каталог на диске
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к созаваемой папке - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция СоздатьПапку(Знач Токен, Знач Путь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
Заголовки = ЗаголовокАвторизации(Токен);
URL = "https://cloud-api.yandex.net/v1/disk/resources";
Href = "href";
Параметры = Новый Структура;
Параметры.Вставить("path", Путь);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Put(URL + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
URLОтвета = Ответ[Href];
Если Не ЗначениеЗаполнено(URLОтвета) Тогда
Возврат Ответ;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URLОтвета, , Заголовки);
Возврат Ответ;
КонецФункции
// Получить объект
// Получает информацию об объекте диска по заданному пути
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к папке или файлу - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьОбъект(Знач Токен, Знач Путь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Параметры.Вставить("path", Путь);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/resources", Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Удалить объект
// Удаляет объект по заданному пути
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к удаляемой папке или файлу - path
// ВКорзину - Булево - В корзину - can
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция УдалитьОбъект(Знач Токен, Знач Путь, Знач ВКорзину = Истина) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьБулево(ВКорзину);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Параметры.Вставить("path" , Путь);
Параметры.Вставить("permanently", Не ВКорзину);
Ответ = OPI_Инструменты.Delete("https://cloud-api.yandex.net/v1/disk/resources", Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Создать копию объекта
// Создает копию объекта по заданному пути и пути к оригиналу
//
//
// Параметры:
// Токен - Строка - Токен - token
// Оригинал - Строка - Путь к оригинальному файлу или каталогу - from
// Путь - Строка - Путь назначения для копии - to
// Перезаписывать - Булево - Перезаписывать если файл с таким именем уже существует - rewrite
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция СоздатьКопиюОбъекта(Знач Токен, Знач Оригинал, Знач Путь, Знач Перезаписывать = Ложь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Оригинал);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьБулево(Перезаписывать);
Заголовки = ЗаголовокАвторизации(Токен);
URL = "https://cloud-api.yandex.net/v1/disk/resources/copy";
Href = "href";
Параметры = Новый Структура;
Параметры.Вставить("from" , Оригинал);
Параметры.Вставить("path" , Путь);
Параметры.Вставить("overwrite" , Перезаписывать);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Post(URL + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
URLОтвета = Ответ[Href];
Если Не ЗначениеЗаполнено(URLОтвета) Тогда
Возврат Ответ;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URLОтвета, , Заголовки);
Возврат Ответ;
КонецФункции
// Получить ссылку для скачивания
// Получает ссылку для скачивания файла
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к файлу для скачивания - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьСсылкуДляСкачивания(Знач Токен, Знач Путь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Параметры.Вставить("path", Путь);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/resources/download", Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Скачать файл
// Скачивает файл по указанному пути
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к файлу для скачивания - path
// ПутьСохранения - Строка - Путь сохранения файла - out
//
// ПутьСохранения - Строка - Путь сохранения файла - out
//
// Возвращаемое значение:
// ДвоичныеДанные,Строка - Двоичные данные или путь к файлу при указании параметра ПутьСохранения
Функция СкачатьФайл(Знач Токен, Знач Путь, Знач ПутьСохранения = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ПутьСохранения);
Ответ = ПолучитьСсылкуДляСкачивания(Токен, Путь);
URL = Ответ["href"];
Если Не ЗначениеЗаполнено(URL) Тогда
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URL, , , ПутьСохранения);
Возврат Ответ;
КонецФункции
// Получить список файлов
// Получает список файлов с или без отбора по типу
// Список доступных типов: audio, backup, book, compressed, data, development,
// diskimage, document, encoded, executable, flash, font,
// Список доступных типов: audio, backup, book, compressed, data, development,
// diskimage, document, encoded, executable, flash, font,
// mage, settings, spreadsheet, text, unknown, video, web
//
//
// Параметры:
// Токен - Строка - Токен - token
// Количество - Число,Строка - Количество возвращаемых объектов - amount
// СмещениеОтНачала - Число - Смещение для получение объектов не из начала списка - offset
// ОтборПоТипу - Строка - Отбор по типу файла - type
// СортироватьПоДате - Булево - Истина > сортировать по дате, Ложь > по алфавиту - datesort
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьСписокФайлов(Знач Токен
@ -263,50 +263,50 @@
, Знач СмещениеОтНачала = 0
, Знач ОтборПоТипу = ""
, Знач СортироватьПоДате = Ложь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Количество);
OPI_ПреобразованиеТипов.ПолучитьСтроку(СмещениеОтНачала);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ОтборПоТипу);
OPI_ПреобразованиеТипов.ПолучитьБулево(СортироватьПоДате);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Количество) Тогда
Параметры.Вставить("limit", OPI_Инструменты.ЧислоВСтроку(Количество));
КонецЕсли;
Если ЗначениеЗаполнено(СмещениеОтНачала) Тогда
Параметры.Вставить("offset", OPI_Инструменты.ЧислоВСтроку(СмещениеОтНачала));
КонецЕсли;
Если ЗначениеЗаполнено(ОтборПоТипу) Тогда
Параметры.Вставить("media_type", ОтборПоТипу);
КонецЕсли;
Если СортироватьПоДате Тогда
Назначение = "last-uploaded";
Иначе
Назначение = "files";
КонецЕсли;
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/resources/" + Назначение, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Переместить объект
// Перемещает объект по заданному пути и пути к оригиналу
//
//
// Параметры:
// Токен - Строка - Токен - token
// Оригинал - Строка - Путь к оригинальному файлу или папке - from
// Путь - Строка - Путь назначение для перемещения - to
// Перезаписывать - Булево - Перезаписывать если файл с таким именем уже существует - rewrite
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПереместитьОбъект(Знач Токен, Знач Оригинал, Знач Путь, Знач Перезаписывать = Ложь) Экспорт
@ -315,97 +315,97 @@
OPI_ПреобразованиеТипов.ПолучитьСтроку(Оригинал);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьБулево(Перезаписывать);
Заголовки = ЗаголовокАвторизации(Токен);
URL = "https://cloud-api.yandex.net/v1/disk/resources/move";
Href = "href";
Параметры = Новый Структура;
Параметры.Вставить("from" , Оригинал);
Параметры.Вставить("path" , Путь);
Параметры.Вставить("overwrite" , Перезаписывать);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Post(URL + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Post(URL + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
Если Не ЗначениеЗаполнено(URLОтвета) Тогда
Возврат Ответ;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URLОтвета, , Заголовки);
Возврат Ответ;
КонецФункции
// Загрузить файл
// Загружает файл на диск по заданному пути
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь для сохранение файла на Диске - path
// Файл - Строка,ДвоичныеДанные - Файл для загрузки - file
// Перезаписывать - Булево - Перезаписывать, если файл с таким именем уже существует - rewrite
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ЗагрузитьФайл(Знач Токен, Знач Путь, Знач Файл, Знач Перезаписывать = Ложь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьБулево(Перезаписывать);
OPI_ПреобразованиеТипов.ПолучитьДвоичныеДанные(Файл);
Заголовки = ЗаголовокАвторизации(Токен);
Href = "href";
Href = "href";
Файл = Новый Структура("file", Файл);
Параметры = Новый Структура;
Параметры.Вставить("path" , Путь);
Параметры.Вставить("overwrite" , Перезаписывать);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/resources/upload", Параметры, Заголовки);
URL = Ответ[Href];
Если Не ЗначениеЗаполнено(URL) Тогда
Возврат Ответ;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.PutMultipart(URL, Новый Структура(), Файл, "multipart", Заголовки);
Возврат Ответ;
КонецФункции
// Загрузить файл по URL
// Загружает файл на диск, забирая его по заданному URL
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь помещения загруженного файла - path
// Адрес - Строка - URL файла - url
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ЗагрузитьФайлПоURL(Знач Токен, Знач Путь, Знач Адрес) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Адрес);
Заголовки = ЗаголовокАвторизации(Токен);
URL = "https://cloud-api.yandex.net/v1/disk/resources/upload";
Параметры = Новый Структура;
Параметры.Вставить("url" , КодироватьСтроку(Адрес, СпособКодированияСтроки.КодировкаURL));
Параметры.Вставить("path", Путь);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Post(URL + Параметры, , Заголовки, Ложь);
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -414,186 +414,186 @@
// Опубликовать объект
// Публикует объект диска в публичный доступ
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к публикуемому объекту - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ОпубликоватьОбъект(Знач Токен, Знач Путь) Экспорт
Возврат ПереключениеОбщегоДоступа(Токен, Путь, Истина);
Возврат ПереключениеОбщегоДоступа(Токен, Путь, Истина);
КонецФункции
// Отменить публикацию объекта
// Отменяет публикацию ранее опубликованного объекта
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к опубликованному ранее объекту - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ОтменитьПубликациюОбъекта(Знач Токен, Знач Путь) Экспорт
Возврат ПереключениеОбщегоДоступа(Токен, Путь, Ложь);
КонецФункции
// Получить список опубликованных объектов.
// Получает список опубликованных объектов
//
//
// Параметры:
// Токен - Строка - Токен - token
// Токен - Строка - Токен - token
// Количество - Число - Количество возвращаемых объектов - amount
// СмещениеОтНачала - Число - Смещение для получение объектов не из начала списка - offset
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьСписокОпубликованныхОбъектов(Знач Токен, Знач Количество = 0, Знач СмещениеОтНачала = 0) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Количество);
OPI_ПреобразованиеТипов.ПолучитьСтроку(СмещениеОтНачала);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Количество) Тогда
Параметры.Вставить("limit", Количество);
КонецЕсли;
Если ЗначениеЗаполнено(СмещениеОтНачала) Тогда
Параметры.Вставить("offset", СмещениеОтНачала);
КонецЕсли;
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/resources/public", Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить публичный объект
// Получает информацию об опубликованном объекте по его URL
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - Адрес объекта - url
// URL - Строка - Адрес объекта - url
// Количество - Число - Количество возвращаемых вложенных объектов (для каталога) - amount
// СмещениеОтНачала - Число - Смещение для получение вложенных объектов не из начала списка - offset
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьПубличныйОбъект(Знач Токен, Знач URL, Знач Количество = 0, Знач СмещениеОтНачала = 0) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(URL);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Количество);
OPI_ПреобразованиеТипов.ПолучитьСтроку(СмещениеОтНачала);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Количество) Тогда
Параметры.Вставить("limit", OPI_Инструменты.ЧислоВСтроку(Количество));
КонецЕсли;
Если ЗначениеЗаполнено(СмещениеОтНачала) Тогда
Параметры.Вставить("offset", OPI_Инструменты.ЧислоВСтроку(СмещениеОтНачала));
КонецЕсли;
Параметры.Вставить("public_key", URL);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/public/resources", Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить ссылку скачивания публичного объекта
// Получает прямую ссылку для скачивания публичного объекта
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - Адрес объекта - url
// Путь - Строка - Путь внутри объекта - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьСсылкуСкачиванияПубличногоОбъекта(Знач Токен, Знач URL, Знач Путь = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(URL);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Путь) Тогда
Параметры.Вставить("path", Путь);
КонецЕсли;
Параметры.Вставить("public_key", URL);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/public/resources/download", Параметры, Заголовки);
Возврат Ответ;
Возврат Ответ;
КонецФункции
// Сохранить публичный объект на диск
// Сохраняет публичный объект на ваш диск
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - Адрес объекта - url
// Откуда - Строка - Путь внутри публичного каталога (только для папок) - from
// Куда - Строка - Путь сохранения файла - to
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция СохранитьПубличныйОбъектНаДиск(Знач Токен, Знач URL, Откуда = "", Куда = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(URL);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Откуда);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Куда);
Заголовки = ЗаголовокАвторизации(Токен);
Адрес = "https://cloud-api.yandex.net/v1/disk/public/resources/save-to-disk";
Href = "href";
Параметры = Новый Структура;
Параметры.Вставить("public_key", КодироватьСтроку(URL, СпособКодированияСтроки.КодировкаURL));
Если ЗначениеЗаполнено(Откуда) Тогда
Параметры.Вставить("path", Откуда);
КонецЕсли;
Если ЗначениеЗаполнено(Куда) Тогда
Параметры.Вставить("save_path", Куда);
КонецЕсли;
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Post(Адрес + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
URLОтвета = Ответ[Href];
Если Не ЗначениеЗаполнено(URLОтвета) Тогда
Возврат Ответ;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URLОтвета, , Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти
#КонецОбласти
@ -601,42 +601,42 @@
#Область СлужебныеПроцедурыИФункции
Функция ЗаголовокАвторизации(Знач Токен)
Заголовки = Новый Соответствие;
Заголовки.Вставить("Authorization", "OAuth " + Токен);
Возврат Заголовки;
КонецФункции
Функция ПереключениеОбщегоДоступа(Знач Токен, Знач Путь, Знач ОбщийДоступ)
Функция ПереключениеОбщегоДоступа(Знач Токен, Знач Путь, Знач ОбщийДоступ)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьБулево(ОбщийДоступ);
Заголовки = ЗаголовокАвторизации(Токен);
Назначение = ?(ОбщийДоступ, "publish", "unpublish");
Href = "href";
URL = "https://cloud-api.yandex.net/v1/disk/resources/" + Назначение;
Параметры = Новый Структура;
Параметры.Вставить("path", Путь);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Put(URL + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
Если Не ЗначениеЗаполнено(URLОтвета) Тогда
Возврат Ответ;
КонецЕсли;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URLОтвета, , Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти

38
src/ru/OInt/core/Modules/OPI_YandexID.os
View File

@ -41,77 +41,77 @@
// Получить код подтверждения
// Получает код подтверждения и адрес страницы, на которой его необходимо ввести
//
//
// Параметры:
// ClientId - Строка - Client id - id
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьКодПодтверждения(Знач ClientId) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientId);
Параметры = Новый Структура("client_id", ClientId);
Ответ = OPI_Инструменты.Post("https://oauth.yandex.ru/device/code", Параметры, , Ложь);
Возврат Ответ;
КонецФункции
// Преобразовать код в токен
// Преобразовывает код в токен после ввода кода при выполнении ПолучитьКодПодтверждения
//
//
// Параметры:
// ClientId - Строка - Client id - id
// ClientSecret - Строка - Client secret - secret
// КодУстройства - Строка - device_code из ПолучитьКодПодтверждения() - device
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПреобразоватьКодВТокен(Знач ClientId, Знач ClientSecret, Знач КодУстройства) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientId);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientSecret);
OPI_ПреобразованиеТипов.ПолучитьСтроку(КодУстройства);
Параметры = Новый Структура;
Параметры.Вставить("grant_type" , "device_code");
Параметры.Вставить("code" , КодУстройства);
Параметры.Вставить("client_id" , ClientId);
Параметры.Вставить("client_secret" , ClientSecret);
Ответ = OPI_Инструменты.Post("https://oauth.yandex.ru/token", Параметры, , Ложь);
Возврат Ответ;
КонецФункции
// Обновить токен
// Обновляет токен по Refresh token
//
//
// Параметры:
// ClientId - Строка - Client id - id
// ClientSecret - Строка - Client secret - secret
// RefreshToken - Строка - Refresh token - refresh
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ОбновитьТокен(Знач ClientId, Знач ClientSecret, Знач RefreshToken) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientId);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientSecret);
OPI_ПреобразованиеТипов.ПолучитьСтроку(RefreshToken);
Параметры = Новый Структура;
Параметры.Вставить("grant_type" , "refresh_token");
Параметры.Вставить("refresh_token" , RefreshToken);
Параметры.Вставить("client_id" , ClientId);
Параметры.Вставить("client_secret" , ClientSecret);
Ответ = OPI_Инструменты.Post("https://oauth.yandex.ru/token", Параметры, , Ложь);
Возврат Ответ;
КонецФункции
#КонецОбласти

4
src/ru/OInt/tests/Modules/Coverage_ЗапускВсехТестов.os
View File

@ -1,8 +1,8 @@
#Использовать "./internal"
#Использовать "./internal"
#Использовать "../../tools"
Тесты = OPI_ПолучениеДанныхТестов.СформироватьТестыАссертс();
Для Каждого Тест Из Тесты Цикл
Выполнить("OPI_Тесты." + Тест + "()");
КонецЦикла;
КонецЦикла;

6860
src/ru/OInt/tests/Modules/internal/OPI_Тесты.os
View File

File diff suppressed because it is too large Load Diff

216
src/ru/OInt/tools/Modules/OPI_ПолучениеДанныхТестов.os
View File

@ -46,10 +46,10 @@
#Область СлужебныйПрограммныйИнтерфейс
Функция ПолучитьСоответствиеРазделовТестирования() Экспорт
СтандартныеЗависимости = "[Decode, Build]";
ЗависимостиГугл = "Testing-GoogleWorkspace";
Разделы = Новый Структура;
Разделы.Вставить("Telegram" , СтандартныеЗависимости);
Разделы.Вставить("VK" , СтандартныеЗависимости);
@ -57,7 +57,7 @@
Разделы.Вставить("Twitter" , СтандартныеЗависимости);
Разделы.Вставить("YandexDisk" , СтандартныеЗависимости);
Разделы.Вставить("GoogleWorkspace", СтандартныеЗависимости);
Разделы.Вставить("GoogleCalendar" , ЗависимостиГугл);
Разделы.Вставить("GoogleCalendar" , ЗависимостиГугл);
Разделы.Вставить("GoogleDrive" , ЗависимостиГугл);
Разделы.Вставить("GoogleSheets" , ЗависимостиГугл);
Разделы.Вставить("Notion" , СтандартныеЗависимости);
@ -65,13 +65,13 @@
Разделы.Вставить("Airtable" , СтандартныеЗависимости);
Разделы.Вставить("Dropbox" , СтандартныеЗависимости);
Разделы.Вставить("Bitrix24" , СтандартныеЗависимости);
Возврат Разделы;
КонецФункции
Функция ПолучитьТаблицуТестов() Экспорт
Телеграм = "Telegram";
ВКонтакте = "VK";
ЯДиск = "YandexDisk";
@ -86,13 +86,13 @@
АирТ = "Airtable";
ДропБокс = "Dropbox";
Битрикс = "Bitrix24";
ТаблицаТестов = Новый ТаблицаЗначений;
ТаблицаТестов.Колонки.Добавить("Метод");
ТаблицаТестов.Колонки.Добавить("Синоним");
ТаблицаТестов.Колонки.Добавить("Раздел");
НовыйТест(ТаблицаТестов, "Телеграм_ПолучитьИнформациюБота" , "Получить информацию бота" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_ПолучитьИнформациюБота" , "Получить информацию бота" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_ПолучитьОбновления" , "Получить обновления" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_УстановитьWebhook" , "Установить Webhook" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_ОтправитьТекстовоеСообщение" , "Отправить текстовое сообщение" , Телеграм);
@ -114,7 +114,7 @@
НовыйТест(ТаблицаТестов, "Телеграм_СоздатьУдалитьТемуФорума" , "Создать/Удалить тему форума" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_ИзменитьИмяГлавнойТемы" , "Изменить имя главной темы" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_СкрытьПоказатьГлавнуюТему" , "Скрыть/Показать главную тему" , Телеграм);
НовыйТест(ТаблицаТестов, "ВК_СоздатьСсылкуТокена" , "Создать ссылку получения токена", ВКонтакте);
НовыйТест(ТаблицаТестов, "ВК_СоздатьУдалитьПост" , "Создать/Удалить пост" , ВКонтакте);
НовыйТест(ТаблицаТестов, "ВК_СоздатьСоставнойПост" , "Создать/Удалить составной пост" , ВКонтакте);
@ -135,7 +135,7 @@
НовыйТест(ТаблицаТестов, "ВК_ПолучитьСписокСвойств" , "Получить список свойств" , ВКонтакте);
НовыйТест(ТаблицаТестов, "ВК_ПолучитьСписокЗаказов" , "Получить список заказов" , ВКонтакте);
НовыйТест(ТаблицаТестов, "ВК_ЗагрузитьВидео" , "Загрузить видео" , ВКонтакте);
НовыйТест(ТаблицаТестов, "ЯДиск_ПолучитьИнформациюОДиске" , "Получить информацию о диске" , ЯДиск);
НовыйТест(ТаблицаТестов, "ЯДиск_СоздатьПапку" , "Создать папку" , ЯДиск);
НовыйТест(ТаблицаТестов, "ЯДиск_ЗагрузитьПоАдресуПолучитьОбъект", "Загрузить по URL и получить" , ЯДиск);
@ -146,25 +146,25 @@
НовыйТест(ТаблицаТестов, "ЯДиск_ПереместитьОбъект" , "Переместить объект" , ЯДиск);
НовыйТест(ТаблицаТестов, "ЯДиск_ДействияПубличныхОбъектов" , "Действия с публичными объектами", ЯДиск);
НовыйТест(ТаблицаТестов, "ЯДиск_ПолучитьСписокОпубликованных" , "Получить список опубликованных" , ЯДиск);
НовыйТест(ТаблицаТестов, "ГВ_ПолучитьСсылкуАвторизации" , "Получить ссылку авторизации" , ВСпейс);
НовыйТест(ТаблицаТестов, "ГВ_ПолучитьТокен" , "Получить токен" , ВСпейс);
НовыйТест(ТаблицаТестов, "ГВ_ОбновитьТокен" , "Обновить токен" , ВСпейс);
НовыйТест(ТаблицаТестов, "ГК_ПолучитьСписокКалендарей" , "Получить список календарей" , Календарь);
НовыйТест(ТаблицаТестов, "ГК_СоздатьУдалитьКалендарь" , "Создать/Удалить календарь" , Календарь);
НовыйТест(ТаблицаТестов, "ГК_СоздатьУдалитьСобытие" , "Создать/Удалить событие" , Календарь);
НовыйТест(ТаблицаТестов, "ГК_ПолучитьСписокСобытий" , "Получить список событий" , Календарь);
НовыйТест(ТаблицаТестов, "ГД_ПолучитьСписокКаталогов" , "Получить список каталогов" , Драйв);
НовыйТест(ТаблицаТестов, "ГД_ЗагрузитьУдалитьФайл" , "Загрузить/Удалить Файл" , Драйв);
НовыйТест(ТаблицаТестов, "ГД_СоздатьУдалитьКомментарий" , "Создать/Удалить кооментарий" , Драйв);
НовыйТест(ТаблицаТестов, "ГД_СоздатьКаталог" , "Создать/Удалить каталог" , Драйв);
НовыйТест(ТаблицаТестов, "ГТ_СоздатьТаблицу" , "Создать таблицу" , Таблицы);
НовыйТест(ТаблицаТестов, "ГТ_ПолучитьТаблицу" , "Получить таблицу" , Таблицы);
НовыйТест(ТаблицаТестов, "ГТ_ЗаполнитьОчиститьЯчейки" , "Заполнить/Очистить ячейки" , Таблицы);
НовыйТест(ТаблицаТестов, "Твиттер_ПолучитьСсылкуАвторизации" , "Получить ссылку авторизации" , Твиттер);
НовыйТест(ТаблицаТестов, "Твиттер_ОбновитьТокен" , "Обновить токен" , Твиттер);
НовыйТест(ТаблицаТестов, "Твиттер_СоздатьТекстовыйТвит" , "Текстовый твит" , Твиттер);
@ -172,7 +172,7 @@
НовыйТест(ТаблицаТестов, "Твиттер_СоздатьТвитСВидео" , "Твит с видео" , Твиттер);
НовыйТест(ТаблицаТестов, "Твиттер_СоздатьТвитСГиф" , "Твит с гиф" , Твиттер);
НовыйТест(ТаблицаТестов, "Твиттер_СоздатьТвитСОпросом" , "Твит с опросом" , Твиттер);
НовыйТест(ТаблицаТестов, "Вайбер_ПолучитьИнформациюОКанале" , "Получить информацию канала" , Вайбер);
НовыйТест(ТаблицаТестов, "Вайбер_ПолучитьДанныеПользователя" , "Получить данные пользователя" , Вайбер);
НовыйТест(ТаблицаТестов, "Вайбер_ПолучитьОнлайнПользователей" , "Получить онлайн пользователей" , Вайбер);
@ -182,7 +182,7 @@
НовыйТест(ТаблицаТестов, "Вайбер_ОтправитьКонтакт" , "Отправить контакт" , Вайбер);
НовыйТест(ТаблицаТестов, "Вайбер_ОтправитьЛокацию" , "Отправить локацию" , Вайбер);
НовыйТест(ТаблицаТестов, "Вайбер_ОтправитьСсылку" , "Отправить ссылку" , Вайбер);
НовыйТест(ТаблицаТестов, "Ноушн_СоздатьСтраницу" , "Создать страницу" , Ноушн);
НовыйТест(ТаблицаТестов, "Ноушн_СоздатьИзменитьБазу" , "Создать/Изменить базу" , Ноушн);
НовыйТест(ТаблицаТестов, "Ноушн_ПолучитьИнформациюОСтранице" , "Получить информацию о странице" , Ноушн);
@ -192,7 +192,7 @@
НовыйТест(ТаблицаТестов, "Ноушн_СоздатьУдалитьБлок" , "Создать/Удалить блок" , Ноушн);
НовыйТест(ТаблицаТестов, "Ноушн_ПолучитьПользователей" , "Получить пользователей" , Ноушн);
НовыйТест(ТаблицаТестов, "Ноушн_ПолучитьДанныеПользователя" , "Получить данные пользователя" , Ноушн);
НовыйТест(ТаблицаТестов, "Слак_ПолучитьИнформациюОБоте" , "Получить информацию о боте" , Слак);
НовыйТест(ТаблицаТестов, "Слак_ПолучитьСписокПользователей" , "Получить список пользователей" , Слак);
НовыйТест(ТаблицаТестов, "Слак_ПолучитьСписокОбластей" , "Получить список областей" , Слак);
@ -206,12 +206,12 @@
НовыйТест(ТаблицаТестов, "Слак_ЗагрузитьУдалитьФайл" , "Загрузить/Удалить файл" , Слак);
НовыйТест(ТаблицаТестов, "Слак_ПолучитьСписокВФ" , "Получить список внеш. файлов" , Слак);
НовыйТест(ТаблицаТестов, "Слак_ЗагрузитьУдалитьВФ" , "Загрузить/Удалить внеш. файл" , Слак);
НовыйТест(ТаблицаТестов, "АТ_СоздатьБазу" , "Создать/Изменить базу" , АирТ);
НовыйТест(ТаблицаТестов, "АТ_СоздатьТаблицу" , "Создать/Изменить таблицу" , АирТ);
НовыйТест(ТаблицаТестов, "АТ_СоздатьПоле" , "Создать/Изменить поле" , АирТ);
НовыйТест(ТаблицаТестов, "АТ_СоздатьУдалитьЗаписи" , "Создать/Удалить записи" , АирТ);
НовыйТест(ТаблицаТестов, "ДропБокс_ПолучитьОбновитьТокен" , "Получить/Обновить токен" , ДропБокс);
НовыйТест(ТаблицаТестов, "ДропБокс_ЗагрузитьФайл" , "Загрузить файл" , ДропБокс);
НовыйТест(ТаблицаТестов, "ДропБокс_ЗагрузитьФайлПоURL" , "Загрузить файл по URL" , ДропБокс);
@ -220,7 +220,7 @@
НовыйТест(ТаблицаТестов, "ДропБокс_ПолучитьАккаунт" , "Получить данные аккаунта" , ДропБокс);
НовыйТест(ТаблицаТестов, "ДропБокс_РаботаСДоступами" , "Работа с доступами" , ДропБокс);
НовыйТест(ТаблицаТестов, "ДропБокс_ПолучитьСписокФайловПапки" , "Получить список файлов папки" , ДропБокс);
НовыйТест(ТаблицаТестов, "Б24_РаботаСТокеном" , "Работа с токеном" , Битрикс);
НовыйТест(ТаблицаТестов, "Б24_СерверноеВремя" , "Серверное время" , Битрикс);
НовыйТест(ТаблицаТестов, "Б24_РаботаСНовостями" , "Работа с новостями" , Битрикс);
@ -231,215 +231,215 @@
НовыйТест(ТаблицаТестов, "Б24_УчетРабочегоВремени" , "Учет рабочего времени" , Битрикс);
НовыйТест(ТаблицаТестов, "Б24_РаботаСЧатами" , "Работа с чатами" , Битрикс);
НовыйТест(ТаблицаТестов, "Б24_РаботаСУведомлениями" , "Работа с уведомлениями" , Битрикс);
Возврат ТаблицаТестов;
КонецФункции
КонецФункции
Функция ОжидаетЧто(Значение) Экспорт
Попытка
Модуль = ПолучитьОбщийМодуль("ЮТест");
Ожидаем = ТипЗнч(Модуль) = Тип("ОбщийМодуль");
Возврат Модуль.ОжидаетЧто(Значение);
Возврат Модуль.ОжидаетЧто(Значение);
Исключение
Возврат Ожидаем.Что(Значение);
КонецПопытки;
КонецФункции
Функция СформироватьТестыЯкс() Экспорт
Модуль = ПолучитьОбщийМодуль("ЮТТесты");
Разделы = ПолучитьСоответствиеРазделовТестирования();
ТаблицаТестов = ПолучитьТаблицуТестов();
Для Каждого Раздел Из Разделы Цикл
ТекущийРаздел = Раздел.Ключ;
Отбор = Новый Структура("Раздел", ТекущийРаздел);
ТестыРаздела = ТаблицаТестов.НайтиСтроки(Отбор);
Набор = Модуль.ДобавитьТестовыйНабор(ТекущийРаздел);
Для Каждого Тест Из ТестыРаздела Цикл
Набор.ДобавитьСерверныйТест(Тест.Метод, Тест.Синоним);
КонецЦикла;
КонецЦикла;
Возврат "";
КонецФункции
Функция СформироватьТестыАссертс() Экспорт
ТаблицаТестов = ПолучитьТаблицуТестов();
МассивТестов = Новый Массив;
Для Каждого Тест Из ТаблицаТестов Цикл
Для Каждого Тест Из ТаблицаТестов Цикл
МассивТестов.Добавить(Тест.Метод);
КонецЦикла;
Возврат МассивТестов;
КонецФункции
Функция ПолучитьПараметр(Параметр) Экспорт
Функция ПолучитьПараметр(Параметр) Экспорт
Путь = ПутьКФайлуДанных();
Путь = ПутьКФайлуДанных();
Возврат ПолучитьЗначениеИзФайла(Параметр, Путь);
КонецФункции
Функция ПолучитьДвоичные(Параметр) Экспорт
Путь = ПутьКФайлуДанных();
Путь = ПутьКФайлуДанных();
ПараметрЛокальный = Параметр + "Local";
ЗначениеОсновной = ПолучитьЗначениеИзФайла(Параметр , Путь);
ЗначениеЛокальный = ПолучитьЗначениеИзФайла(ПараметрЛокальный, Путь);
ФайлЛокальный = Новый Файл(ЗначениеЛокальный);
Если ФайлЛокальный.Существует() Тогда
Значение = Новый ДвоичныеДанные(ЗначениеЛокальный);
Иначе
Значение = ЗначениеОсновной;
КонецЕсли;
Если ТипЗнч(Значение) = Тип("Строка") Тогда
Значение = ПолучитьФайлПути(Значение, ПараметрЛокальный);
Значение = ПолучитьФайлПути(Значение, ПараметрЛокальный);
КонецЕсли;
Возврат Значение;
КонецФункции
Функция ПолучитьФайлПути(Знач Путь, ПараметрЛокальный, Знач СохранятьЛокально = Истина) Экспорт
Если СтрНайти(Путь, "http") > 0
Если СтрНайти(Путь, "http") > 0
Или СтрНайти(Путь, "www") > 0 Тогда
ИВФ = ПолучитьИмяВременногоФайла();
ИВФ = ПолучитьИмяВременногоФайла();
КопироватьФайл(Путь, ИВФ);
Путь = ИВФ;
Путь = ИВФ;
Двоичные = Новый ДвоичныеДанные(Путь);
Если СохранятьЛокально Тогда
ЗаписатьПараметр(ПараметрЛокальный, ИВФ);
Иначе
УдалитьФайлы(ИВФ);
КонецЕсли;
Иначе
Двоичные = Новый ДвоичныеДанные(Путь);
КонецЕсли;
Возврат Двоичные;
КонецФункции
Процедура ПараметрВКоллекцию(Параметр, Коллекция) Экспорт
Значение = ПолучитьПараметр(Параметр);
Коллекция.Вставить(Параметр, Значение);
КонецПроцедуры
Процедура ДвоичныеВКоллекцию(Параметр, Коллекция) Экспорт
Значение = ПолучитьДвоичные(Параметр);
Коллекция.Вставить(Параметр, Значение);
КонецПроцедуры
Процедура ЗаписатьПараметр(Параметр, Значение) Экспорт
Путь = ПутьКФайлуДанных();
Путь = ПутьКФайлуДанных();
ЗаписатьПараметрВФайл(Параметр, Значение, Путь);
КонецПроцедуры
Процедура ЗаписатьЛог(Знач Результат, Знач Метод, Знач Библиотека = "") Экспорт
Шапка = Строка(OPI_Инструменты.ПолучитьТекущуюДату()) + " | " + Метод;
Попытка
Данные = OPI_Инструменты.JSONСтрокой(Результат);
Исключение
Данные = "Не JSON: " + Строка(Результат);
КонецПопытки;
Данные = " " + Данные;
Данные = " " + Данные;
Сообщить(Шапка);
Сообщить(Символы.ПС);
Сообщить(Данные);
Сообщить(Символы.ПС);
Сообщить("---------------------------------");
Сообщить(Символы.ПС);
Если ЗначениеЗаполнено(Библиотека) Тогда
ЗаписатьФайлЛога(Данные, Метод, Библиотека);
КонецЕсли;
КонецПроцедуры
#КонецОбласти
#Область СлужебныеПроцедурыИФункции
Функция ПолучитьЗначениеИзФайла(Параметр, Путь)
Значения = OPI_Инструменты.ПрочитатьJSONФайл(Путь);
Функция ПолучитьЗначениеИзФайла(Параметр, Путь)
Значения = OPI_Инструменты.ПрочитатьJSONФайл(Путь);
Возврат ?(Значения.Свойство(Параметр), Значения[Параметр], "");
КонецФункции
Функция ПутьКФайлуДанных()
Путь = "";
Путь = "";
ВозможныеПути = Новый Массив;
ВозможныеПути.Добавить("./data.json");
ВозможныеПути.Добавить("C:\GDrive\Мой диск\data.json");
ВозможныеПути.Добавить("D:\GD\Мой диск\data.json");
Для Каждого ВозможныйПуть Из ВозможныеПути Цикл
ФайлРепозитория = Новый Файл(ВозможныйПуть);
Если ФайлРепозитория.Существует() Тогда
Путь = ВозможныйПуть;
КонецЕсли;
КонецЕсли;
КонецЦикла;
Возврат Путь;
КонецФункции
Функция ПолучитьОбщийМодуль(Знач Имя)
Модуль = Вычислить(Имя);
Возврат Модуль;
Модуль = Вычислить(Имя);
Возврат Модуль;
КонецФункции
Процедура НовыйТест(ТаблицаЗначений, Знач Метод, Знач Синоним, Знач Раздел)
НовыйТест = ТаблицаЗначений.Добавить();
НовыйТест = ТаблицаЗначений.Добавить();
НовыйТест.Метод = Метод;
НовыйТест.Синоним = Синоним;
НовыйТест.Раздел = Раздел;
КонецПроцедуры
Процедура ЗаписатьПараметрВФайл(Знач Параметр, Знач Значение, Знач Путь)
Значения = OPI_Инструменты.ПрочитатьJSONФайл(Путь);
Значения.Вставить(Параметр, Значение);
@ -452,37 +452,37 @@
КонецПроцедуры
Процедура ЗаписатьФайлЛога(Знач Данные, Знач Метод, Знач Библиотека)
Попытка
ПутьЛогов = "./docs/ru/results";
ПутьЛоговБиблиотеки = ПутьЛогов + "/" + Библиотека;
КаталогЛогов = Новый Файл(ПутьЛогов);
Если Не КаталогЛогов.Существует() Тогда
СоздатьКаталог(ПутьЛогов);
КонецЕсли;
КаталогЛоговБиблиотеки = Новый Файл(ПутьЛоговБиблиотеки);
Если Не КаталогЛоговБиблиотеки.Существует() Тогда
СоздатьКаталог(ПутьЛоговБиблиотеки);
КонецЕсли;
ПутьКФайлу = ПутьЛоговБиблиотеки + "/" + Метод + ".log";
ФайлЛога = Новый Файл(ПутьКФайлу);
Если Не ФайлЛога.Существует() Тогда
ДокументЛога = Новый ТекстовыйДокумент;
ДокументЛога.УстановитьТекст(Данные);
ДокументЛога.Записать(ПутьКФайлу);
КонецЕсли;
Исключение
Сообщить("Не удалось записать файл лога!: " + ОписаниеОшибки());
Сообщить("Не удалось записать файл лога!: " + ОписаниеОшибки());
КонецПопытки;
КонецПроцедуры
#КонецОбласти

230
src/ru/OInt/tools/Modules/OPI_ПреобразованиеТипов.os
View File

@ -39,268 +39,268 @@
#Область СлужебныйПрограммныйИнтерфейс
Процедура ПолучитьДвоичныеДанные(Значение) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Попытка
Попытка
Если ТипЗнч(Значение) = Тип("ДвоичныеДанные") Тогда
Возврат;
Иначе
Файл = Новый Файл(Значение);
Если Файл.Существует() Тогда
Значение = Новый ДвоичныеДанные(Значение);
ИначеЕсли СтрНайти(Значение, "//") Тогда
Значение = OPI_Инструменты.Get(Значение);
Иначе
Значение = Base64Значение(Значение);
КонецЕсли;
КонецЕсли;
Исключение
ВызватьИсключение "Ошибка получения двоичных данных из параметра: " + ОписаниеОшибки();
КонецПопытки;
КонецПроцедуры
Процедура ПолучитьДвоичныеИлиПоток(Значение) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Если ТипЗнч(Значение) <> Тип("Строка") Тогда
ПолучитьДвоичныеДанные(Значение);
Возврат;
КонецЕсли;
Файл = Новый Файл(Значение);
Если Файл.Существует() Тогда
Значение = Новый ФайловыйПоток(Значение, РежимОткрытияФайла.Открыть);
Значение = Новый ФайловыйПоток(Значение, РежимОткрытияФайла.Открыть);
Иначе
ПолучитьДвоичныеДанные(Значение);
КонецЕсли;
КонецПроцедуры
Процедура ПолучитьКоллекцию(Значение) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Попытка
Попытка
ИсходноеЗначение = Значение;
Если ЭтоКоллекция(Значение) Тогда
Возврат;
Иначе
Если ТипЗнч(Значение) = Тип("ДвоичныеДанные") Тогда
Значение = ПолучитьСтрокуИзДвоичныхДанных(Значение);
Значение = ПолучитьСтрокуИзДвоичныхДанных(Значение);
Иначе
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
КонецЕсли;
Файл = Новый Файл(Значение);
ЧтениеJSON = Новый ЧтениеJSON;
Если Файл.Существует() Тогда
ЧтениеJSON.ОткрытьФайл(Значение);
ИначеЕсли СтрНачинаетсяС(нРег(Значение), "http") Тогда
ИВФ = ПолучитьИмяВременногоФайла();
КопироватьФайл(Значение, ИВФ);
ЧтениеJSON.ОткрытьФайл(ИВФ);
ЧтениеJSON.Прочитать();
УдалитьФайлы(ИВФ);
Иначе
ЧтениеJSON.УстановитьСтроку(СокрЛП(Значение));
КонецЕсли;
Значение = ПрочитатьJSON(ЧтениеJSON, Истина, Неопределено, ФорматДатыJSON.ISO);
ЧтениеJSON.Закрыть();
Если (Не ЭтоКоллекция(Значение)) Или Не ЗначениеЗаполнено(Значение) Тогда
Значение = ИсходноеЗначение;
ПолучитьМассив(Значение);
КонецЕсли;
КонецЕсли;
Исключение
Значение = ИсходноеЗначение;
ПолучитьМассив(Значение);
ПолучитьМассив(Значение);
КонецПопытки;
КонецПроцедуры
Процедура ПолучитьМассив(Значение) Экспорт
Если ТипЗнч(Значение) = Тип("Массив") Тогда
Возврат;
КонецЕсли;
Если ТипЗнч(Значение) = Тип("Строка")
Если ТипЗнч(Значение) = Тип("Строка")
И СтрНачинаетсяС(Значение, "[")
И СтрЗаканчиваетсяНа(Значение, "]") Тогда
ЗапятаяВКавычках = "','";
Значение = СтрЗаменить(Значение, "['" , "");
Значение = СтрЗаменить(Значение, "']" , "");
Значение = СтрЗаменить(Значение, "', '" , ЗапятаяВКавычках);
Значение = СтрЗаменить(Значение, "' , '", ЗапятаяВКавычках);
Значение = СтрЗаменить(Значение, "' ,'" , ЗапятаяВКавычках);
Значение = СтрРазделить(Значение, ЗапятаяВКавычках, Ложь);
Для Н = 0 По Значение.ВГраница() Цикл
Для Н = 0 По Значение.ВГраница() Цикл
Значение[Н] = СокрЛП(Значение[Н]);
КонецЦикла;
Иначе
Если ТипЗнч(Значение) = Тип("Число") Тогда
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
КонецЕсли;
OPI_Инструменты.ЗначениеВМассив(Значение);
КонецЕсли;
КонецПроцедуры
Процедура ПолучитьБулево(Значение) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Попытка
Попытка
Если ТипЗнч(Значение) = Тип("Булево") Тогда
Возврат;
Иначе
Значение = Булево(Значение);
Значение = Булево(Значение);
КонецЕсли;
Исключение
ВызватьИсключение "Ошибка получения данных булево из параметра";
КонецПопытки;
КонецПроцедуры
Процедура ПолучитьСтроку(Значение, Знач ИзИсточника = Ложь) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Попытка
Попытка
Если ЭтоСимвольное(Значение) Тогда
Если Не ИзИсточника Тогда
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
Возврат;
Возврат;
КонецЕсли;
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
Файл = Новый Файл(Значение);
Если Файл.Существует() Тогда
ЧтениеТекста = Новый ЧтениеТекста(Значение);
Значение = ЧтениеТекста.Прочитать();
ЧтениеТекста.Закрыть();
ИначеЕсли СтрНачинаетсяС(нРег(Значение), "http") Тогда
ИВФ = ПолучитьИмяВременногоФайла();
КопироватьФайл(Значение, ИВФ);
ЧтениеТекста = Новый ЧтениеТекста(ИВФ);
Значение = ЧтениеТекста.Прочитать();
ЧтениеТекста.Закрыть();
УдалитьФайлы(ИВФ);
Иначе
Возврат;
КонецЕсли;
ИначеЕсли ТипЗнч(Значение) = Тип("ДвоичныеДанные") Тогда
Значение = ПолучитьСтрокуИзДвоичныхДанных(Значение);
ИначеЕсли ЭтоКоллекция(Значение) Тогда
Значение = OPI_Инструменты.JSONСтрокой(Значение);
Значение = OPI_Инструменты.JSONСтрокой(Значение);
Иначе
Возврат;
КонецЕсли;
Исключение
Значение = Строка(Значение);
Возврат;
КонецПопытки;
КонецПроцедуры
Процедура ПолучитьДату(Значение) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Дата = "Дата";
Попытка
Попытка
Если ТипЗнч(Значение) = Тип(Дата) Тогда
Возврат;
Иначе
Значение = XMLЗначение(Тип(Дата), Значение);
Иначе
Значение = XMLЗначение(Тип(Дата), Значение);
КонецЕсли;
Исключение
ООД = Новый ОписаниеТипов(Дата);
ООД = Новый ОписаниеТипов(Дата);
Значение = ООД.ПривестиЗначение(Значение);
КонецПопытки;
КонецПроцедуры
Процедура ПолучитьЧисло(Значение) Экспорт
ОписаниеТипа = Новый ОписаниеТипов("Число");
Значение = ОписаниеТипа.ПривестиЗначение(Значение);
Значение = ОписаниеТипа.ПривестиЗначение(Значение);
КонецПроцедуры
#КонецОбласти
@ -308,19 +308,19 @@
#Область СлужебныеПроцедурыИФункции
Функция ЭтоКоллекция(Знач Значение)
Возврат ТипЗнч(Значение) = Тип("Массив")
Возврат ТипЗнч(Значение) = Тип("Массив")
Или ТипЗнч(Значение) = Тип("Структура")
Или ТипЗнч(Значение) = Тип("Соответствие");
КонецФункции
КонецФункции
Функция ЭтоСимвольное(Знач Значение)
Возврат ТипЗнч(Значение) = Тип("Строка")
Или ТипЗнч(Значение) = Тип("Число")
Возврат ТипЗнч(Значение) = Тип("Строка")
Или ТипЗнч(Значение) = Тип("Число")
Или ТипЗнч(Значение) = Тип("Дата");
КонецФункции
КонецФункции
#КонецОбласти

650
src/ru/OInt/tools/Modules/internal/Modules/OPI_Инструменты.os
View File

File diff suppressed because it is too large Load Diff

46
src/ru/OInt/tools/Modules/internal/Modules/OPI_Криптография.os
View File

@ -39,75 +39,75 @@
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2019, ООО 1С-Софт
// Все права защищены. Эта программа и сопроводительные материалы предоставляются
// Все права защищены. Эта программа и сопроводительные материалы предоставляются
// в соответствии с условиями лицензии Attribution 4.0 International (CC BY 4.0)
// Текст лицензии доступен по ссылке:
// https://creativecommons.org/licenses/by/4.0/legalcode
///////////////////////////////////////////////////////////////////////////////////////////////////////
Функция HMACSHA256(Знач Ключ, Знач Данные) Экспорт
Возврат HMAC(Ключ, Данные, ХешФункция.SHA256, 64);
КонецФункции
Функция Хеш(ДвоичныеДанные, Тип) Экспорт
Хеширование = Новый ХешированиеДанных(Тип);
Хеширование.Добавить(ДвоичныеДанные);
Возврат Хеширование.ХешСумма;
КонецФункции
Функция HMAC(Знач Ключ, Знач Данные, Тип, РазмерБлока) Экспорт
Дважды = 2;
Если Ключ.Размер() > РазмерБлока Тогда
Ключ = Хеш(Ключ, Тип);
КонецЕсли;
Если Ключ.Размер() <= РазмерБлока Тогда
Ключ = ПолучитьHexСтрокуИзДвоичныхДанных(Ключ);
Ключ = Лев(Ключ + ПовторитьСтроку("00", РазмерБлока), РазмерБлока * Дважды);
Ключ = ПолучитьHexСтрокуИзДвоичныхДанных(Ключ);
Ключ = Лев(Ключ + ПовторитьСтроку("00", РазмерБлока), РазмерБлока * Дважды);
КонецЕсли;
Ключ = ПолучитьБуферДвоичныхДанныхИзДвоичныхДанных(ПолучитьДвоичныеДанныеИзHexСтроки(Ключ));
Ipad = ПолучитьБуферДвоичныхДанныхИзHexСтроки(ПовторитьСтроку("36", РазмерБлока));
Opad = ПолучитьБуферДвоичныхДанныхИзHexСтроки(ПовторитьСтроку("5c", РазмерБлока));
Ipad.ЗаписатьПобитовоеИсключительноеИли(0, Ключ);
Ikeypad = ПолучитьДвоичныеДанныеИзБуфераДвоичныхДанных(ipad);
Opad.ЗаписатьПобитовоеИсключительноеИли(0, Ключ);
Okeypad = ПолучитьДвоичныеДанныеИзБуфераДвоичныхДанных(opad);
Возврат Хеш(СклеитьДвоичныеДанные(okeypad, Хеш(СклеитьДвоичныеДанные(ikeypad, Данные), Тип)), Тип);
КонецФункции
Функция СклеитьДвоичныеДанные(ДвоичныеДанные1, ДвоичныеДанные2) Экспорт
МассивДвоичныхДанных = Новый Массив;
МассивДвоичныхДанных.Добавить(ДвоичныеДанные1);
МассивДвоичныхДанных.Добавить(ДвоичныеДанные2);
Возврат СоединитьДвоичныеДанные(МассивДвоичныхДанных);
КонецФункции
Функция ПовторитьСтроку(Строка, Количество) Экспорт
Части = Новый Массив(Количество);
Для К = 1 По Количество Цикл
Части.Добавить(Строка);
КонецЦикла;
Возврат СтрСоединить(Части, "");
КонецФункции
#КонецОбласти

376
src/ru/OPI/src/CommonModules/OPI_Airtable/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/core/Modules/OPI_Airtable.os
// OneScript: ./OInt/core/Modules/OPI_Airtable.os
// Lib: Airtable
// CLI: airtable
@ -42,91 +42,91 @@
// Получить список баз
// Получает список доступных баз
//
//
// Параметры:
// Токен - Строка - Токен - token
// Отступ - Строка - Идентификатор следующей страницы списка баз из перыдудщего запроса - offset
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ПолучитьСписокБаз(Знач Токен, Знач Отступ = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Отступ);
URL = "https://api.airtable.com/v0/meta/bases";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("offset", Отступ, "Строка", Параметры);
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить таблицы базы
// Получает схему таблиц базы
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы - base
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ПолучитьТаблицыБазы(Знач Токен, Знач База) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
URL = "https://api.airtable.com/v0/meta/bases/" + База + "/tables";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Создать базу
// Создает новую базу данных
//
//
// Параметры:
// Токен - Строка - Токен - token
// РабочееПространство - Строка - Идентификатор рабочего пространства - ws
// Наименование - Строка - Наименование новой базы - title
// КоллекцияТаблиц - Соответствие Из КлючИЗначение - Описание таблиц: Ключ > имя, Значение > массив полей - tablesdata
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция СоздатьБазу(Знач Токен, Знач РабочееПространство, Знач Наименование, Знач КоллекцияТаблиц) Экспорт
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(КоллекцияТаблиц);
Если Не ТипЗнч(КоллекцияТаблиц) = Тип("Структура")
Если Не ТипЗнч(КоллекцияТаблиц) = Тип("Структура")
И Не ТипЗнч(КоллекцияТаблиц) = Тип("Соответствие") Тогда
ВызватьИсключение "Ошибка в данных коллекции таблиц";
КонецЕсли;
URL = "https://api.airtable.com/v0/meta/bases";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
МассивТаблиц = Новый Массив;
Для Каждого Таблица Из КоллекцияТаблиц Цикл
Описание = СформироватьОписаниеТаблицы(Таблица.Ключ, Таблица.Значение);
МассивТаблиц.Добавить(Описание);
КонецЦикла;
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("name" , Наименование , "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("tables" , МассивТаблиц , "Массив", Параметры);
OPI_Инструменты.ДобавитьПоле("workspaceId", РабочееПространство, "Строка", Параметры);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
@ -137,56 +137,56 @@
// Создать таблицу
// Создает новую таблицу в базе
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы - base
// Наименование - Строка - Наименование новой таблицы - title
// МассивПолей - Массив Из Структура - Массив описаний полей - fieldsdata
// Описание - Строка - Описание таблицы - description
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция СоздатьТаблицу(Знач Токен, Знач База, Знач Наименование, Знач МассивПолей, Знач Описание = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
URL = "https://api.airtable.com/v0/meta/bases/" + База + "/tables";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = СформироватьОписаниеТаблицы(Наименование, МассивПолей, Описание);
Параметры = СформироватьОписаниеТаблицы(Наименование, МассивПолей, Описание);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Изменить таблицу
// Изменяет наименование и|или описание базы
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы - base
// Таблица - Строка - Идентификатор таблицы - table
// Наименование - Строка - Новое наименование - title
// Описание - Строка - Новое описание - description
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ИзменитьТаблицу(Знач Токен, Знач База, Знач Таблица, Знач Наименование = "", Знач Описание = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
URL = "https://api.airtable.com/v0/meta/bases/" + База + "/tables/" + Таблица;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("name" , Наименование, "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("description", Описание , "Строка", Параметры);
Ответ = OPI_Инструменты.Patch(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
@ -197,40 +197,40 @@
// Создать поле
// Создет новое поле в таблице
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы - base
// Таблица - Строка - Идентификатор таблицы - table
// СтруктураПоля - Структура Из КлючИЗначение - Описание нового поля - fielddata
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция СоздатьПоле(Знач Токен, Знач База, Знач Таблица, Знач СтруктураПоля) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(СтруктураПоля);
Если Не ТипЗнч(СтруктураПоля) = Тип("Структура")
Если Не ТипЗнч(СтруктураПоля) = Тип("Структура")
И Не ТипЗнч(СтруктураПоля) = Тип("Соответствие") Тогда
ВызватьИсключение "Ошибка в данных описания поля";
КонецЕсли;
URL = "https://api.airtable.com/v0/meta/bases/" + База + "/tables/" + Таблица + "/fields";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Post(URL, СтруктураПоля, Заголовки);
Возврат Ответ;
КонецФункции
// Изменить поле
// Изменяет имя и|или описание существующего поля таблицы
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы База - base
@ -238,152 +238,152 @@
// Поле - Строка - Идентификатор поля - field
// Наименование - Строка - Новое наименование - title
// Описание - Строка - Новое описание - description
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ИзменитьПоле(Знач Токен, Знач База, Знач Таблица, Знач Поле, Знач Наименование = "", Знач Описание = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Поле);
URL = "https://api.airtable.com/v0/meta/bases/"
+ База
+ "/tables/"
+ Таблица
+ "/fields/"
URL = "https://api.airtable.com/v0/meta/bases/"
+ База
+ "/tables/"
+ Таблица
+ "/fields/"
+ Поле;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура();
OPI_Инструменты.ДобавитьПоле("name" , Наименование, "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("description", Описание , "Строка", Параметры);
Ответ = OPI_Инструменты.Patch(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить поле (строковое)
// Получает описание поля строкового типа
//
//
// Параметры:
// Наименование - Строка - Наименование нового поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеСтроковое(Знач Наименование) Экспорт
Возврат ОписаниеПримитивногоПоля(Наименование, "richText");
КонецФункции
// Получить поле (числовое)
// Получает описание поля числового типа
//
//
// Параметры:
// Наименование - Строка - Наименование нового поля - title
// Точность - Число,Строка - Число знаков после запятой - precision
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеНомера(Знач Наименование, Знач Точность = 0) Экспорт
OPI_ПреобразованиеТипов.ПолучитьЧисло(Точность);
СтруктураОпций = Новый Структура("precision", Точность);
Возврат ОписаниеПримитивногоПоля(Наименование, "number", СтруктураОпций);
КонецФункции
// Получить поле (файл)
// Получает описание поля файлового типа
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеВложения(Знач Наименование) Экспорт
Возврат ОписаниеПримитивногоПоля(Наименование, "multipleAttachments");
КонецФункции
// Получить поле (флажок)
// Получает описание поля типа булево
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеФлажка(Знач Наименование) Экспорт
СтруктураОпций = Новый Структура("icon,color", "check", "yellowBright");
Возврат ОписаниеПримитивногоПоля(Наименование, "checkbox", СтруктураОпций);
КонецФункции
// Получить поле (дата)
// Получает описание поля типа дата
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеДаты(Знач Наименование) Экспорт
СтруктураФормата = Новый Структура("format,name", "YYYY-MM-DD", "iso");
СтруктураОпций = Новый Структура("dateFormat", СтруктураФормата);
Возврат ОписаниеПримитивногоПоля(Наименование, "date", СтруктураОпций);
КонецФункции
// Получить поле (email)
// Получает описание поля с электронной почтой
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеПочты(Знач Наименование) Экспорт
Возврат ОписаниеПримитивногоПоля(Наименование, "email");
КонецФункции
// Получить поле (телефон)
// Получает описание поля с номером телефона
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеТелефона(Знач Наименование) Экспорт
Возврат ОписаниеПримитивногоПоля(Наименование, "phoneNumber");
КонецФункции
// Получить поле (url)
// Получает описание поля с URL
//
//
// Параметры:
// Наименование - Строка - Наименование поля - title
//
//
// Возвращаемое значение:
// Структура - Описание поля
Функция ПолучитьПолеСсылки(Знач Наименование) Экспорт
Возврат ОписаниеПримитивногоПоля(Наименование, "url");
КонецФункции
#КонецОбласти
@ -392,67 +392,67 @@
// Получить список записей
// Получает список записей выбранной таблицы
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Отступ - Строка - Иднтификатор следующей страницы данных из предыдущего запроса - offset
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ПолучитьСписокЗаписей(Знач Токен, Знач База, Знач Таблица, Знач Отступ = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура();
OPI_Инструменты.ДобавитьПоле("offset", Отступ, "Строка", Параметры);
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить запись
// Получает данные строки таблицы по идентификатору
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Запись - Строка - Идентификатор записи в таблице - record
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ПолучитьЗапись(Знач Токен, Знач База, Знач Таблица, Знач Запись) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Запись);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + "/" + Запись;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Создать записи
// Создает одну или массив записей по описанию или массиву описаний значений полей
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Данные - Структура, Массив из Структура - Набор или массив наборов пар Ключ : Значение > Поле : Показатель - data
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция СоздатьЗаписи(Знач Токен, Знач База, Знач Таблица, Знач Данные) Экспорт
@ -460,52 +460,52 @@
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(Данные);
Параметры = Новый Структура();
ДобавитьОписаниеДанных(Данные, Параметры);
ДобавитьОписаниеДанных(Данные, Параметры);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
Возврат Ответ;
КонецФункции
// Удалить записи
// Удаляет одну или массив записей по идентификаторам
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Записи - Строка, Массив из Строка - Идентификатор или массив индентификаторов записей - records
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция УдалитьЗаписи(Знач Токен, Знач База, Знач Таблица, Знач Записи) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьМассив(Записи);
СтрокаЗаписей = "";
Для Каждого Запись Из Записи Цикл
СтрокаЗаписей = СтрокаЗаписей
СтрокаЗаписей = СтрокаЗаписей
+ ?(ЗначениеЗаполнено(СтрокаЗаписей), "&", "?")
+ "records[]="
+ OPI_Инструменты.ЧислоВСтроку(Запись);
+ OPI_Инструменты.ЧислоВСтроку(Запись);
КонецЦикла;
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + СтрокаЗаписей;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -514,67 +514,67 @@
// Получить комментарии
// Получает список комментариев к записи в таблице
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Запись - Строка - Идентификатор записи в таблице - record
// Отступ - Строка - Иднтификатор следующей страницы данных из предыдущего запроса - offset
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ПолучитьКомментарии(Знач Токен, Знач База, Знач Таблица, Знач Запись, Знач Отступ = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Запись);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + "/" + Запись + "/comments";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура();
OPI_Инструменты.ДобавитьПоле("offset", Отступ, "Строка", Параметры);
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Создать комментарий
// Создает комментарий к записи в таблице
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Запись - Строка - Идентификатор записи в таблице - record
// Текст - Строка - Текст комментария - text
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция СоздатьКомментарий(Знач Токен, Знач База, Знач Таблица, Знач Запись, Знач Текст) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Запись);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + "/" + Запись + "/comments";
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура();
OPI_Инструменты.ДобавитьПоле("text", Текст, "Строка", Параметры);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Изменить комментарий
// Изменяет текст существующего комментария
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
@ -582,54 +582,54 @@
// Запись - Строка - Идентификатор записи в таблице - record
// Комментарий - Строка - Идентификатор комментария - comment
// Текст - Строка - Новый текст комментария - text
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция ИзменитьКомментарий(Знач Токен, Знач База, Знач Таблица, Знач Запись, Знач Комментарий, Знач Текст) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Запись);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Комментарий);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + "/" + Запись + "/comments/" + Комментарий;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Параметры = Новый Структура();
OPI_Инструменты.ДобавитьПоле("text", Текст, "Строка", Параметры);
Ответ = OPI_Инструменты.Patch(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Удалить комментарий
// Удаляет комментарий к записи таблицы
//
//
// Параметры:
// Токен - Строка - Токен - token
// База - Строка - Идентификатор базы данных - base
// Таблица - Строка - Идентификатор таблицы - table
// Запись - Строка - Идентификатор записи в таблице - record
// Комментарий - Строка - Идентификатор комментария - comment
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Airtable
Функция УдалитьКомментарий(Знач Токен, Знач База, Знач Таблица, Знач Запись, Знач Комментарий) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(База);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Таблица);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Запись);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Комментарий);
URL = "https://api.airtable.com/v0/" + База + "/" + Таблица + "/" + Запись + "/comments/" + Комментарий;
Заголовки = ПолучитьЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -639,58 +639,58 @@
#Область СлужебныеПроцедурыИФункции
Функция ПолучитьЗаголовокАвторизации(Знач Токен)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
Заголовки = Новый Соответствие;
Заголовки.Вставить("Authorization", "Bearer " + Токен);
Возврат Заголовки;
КонецФункции
Функция СформироватьОписаниеТаблицы(Знач Наименование, Знач МассивПолей, Знач Описание = "")
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивПолей);
ОписаниеТаблицы = Новый Структура("name,fields", Наименование, МассивПолей);
OPI_Инструменты.ДобавитьПоле("description", Описание, "Строка", ОписаниеТаблицы);
Возврат ОписаниеТаблицы;
КонецФункции
Функция ОписаниеПримитивногоПоля(Знач Наименование, Знач Тип, Знач Опции = "")
СтруктураПоля = Новый Структура();
OPI_Инструменты.ДобавитьПоле("name" , Наименование, "Строка" , СтруктураПоля);
OPI_Инструменты.ДобавитьПоле("type" , Тип , "Строка" , СтруктураПоля);
OPI_Инструменты.ДобавитьПоле("options", Опции , "Коллекция", СтруктураПоля);
Возврат СтруктураПоля;
КонецФункции
Процедура ДобавитьОписаниеДанных(Знач Данные, Параметры)
Если ТипЗнч(Данные) = Тип("Массив") Тогда
МассивОтправки = Новый Массив;
Для Каждого ОписаниеЗаписи Из Данные Цикл
МассивОтправки.Добавить(Новый Структура("fields", ОписаниеЗаписи));
МассивОтправки.Добавить(Новый Структура("fields", ОписаниеЗаписи));
КонецЦикла;
OPI_Инструменты.ДобавитьПоле("records", МассивОтправки, "Массив", Параметры);
Иначе
OPI_Инструменты.ДобавитьПоле("fields", Данные, "Коллекция", Параметры);
OPI_Инструменты.ДобавитьПоле("fields", Данные, "Коллекция", Параметры);
КонецЕсли;
КонецПроцедуры
#КонецОбласти
#КонецОбласти

1994
src/ru/OPI/src/CommonModules/OPI_Bitrix24/Module.bsl
View File

File diff suppressed because it is too large Load Diff

548
src/ru/OPI/src/CommonModules/OPI_Dropbox/Module.bsl
View File

File diff suppressed because it is too large Load Diff

344
src/ru/OPI/src/CommonModules/OPI_GoogleCalendar/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/core/Modules/OPI_GoogleCalendar.os
// OneScript: ./OInt/core/Modules/OPI_GoogleCalendar.os
// Lib: Google Calendar
// CLI: gcalendar
@ -43,131 +43,131 @@
// Создать календарь
// Создает пустой календарь
//
//
// Параметры:
// Токен - Строка - Токен - token
// Наименование - Строка - Наименование создаваемого календаря - title
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция СоздатьКалендарь(Знач Токен, Знач Наименование) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars";
Параметры = Новый Структура;
Параметры.Вставить("summary" , Наименование);
Параметры.Вставить("timeZone", "Europe/Moscow");
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить календарь
// Получает информацию о календаре по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьМетаданныеКалендаря(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Календарь;
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Календарь;
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Изменить календарь
// Изменяет свойства существуещего календаря
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// Наименование - Строка - Новое наименование - title
// Описание - Строка - Новое описание календаря - description
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ИзменитьМетаданныеКалендаря(Знач Токен
, Знач Календарь
, Знач Наименование = ""
, Знач Описание = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Описание);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Календарь;
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Наименование) Тогда
Параметры.Вставить("summary", Наименование);
КонецЕсли;
Если ЗначениеЗаполнено(Описание) Тогда
Параметры.Вставить("description", Описание);
КонецЕсли;
Ответ = OPI_Инструменты.Patch(URL, Параметры, Заголовки, Истина);
Возврат Ответ;
КонецФункции
// Очистить основной календарь
// Очищает список событий основного календаря
//
//
// Параметры:
// Токен - Строка - Токен - token
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ОчиститьОсновнойКалендарь(Знач Токен) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/primary/clear";
URL = "https://www.googleapis.com/calendar/v3/calendars/primary/clear";
Ответ = OPI_Инструменты.Post(URL, , Заголовки, Ложь);
Возврат Ответ;
КонецФункции
// Удалить календарь
// Удаляет календарь по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьКалендарь(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Календарь;
URL = "https://www.googleapis.com/calendar/v3/calendars/" + Календарь;
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
@ -178,105 +178,105 @@
// Получить список календарей
// Получает массив календарей аккаунта
//
//
// Параметры:
// Токен - Строка - Токен - token
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Массив соответствий данных календарей
Функция ПолучитьСписокКалендарей(Знач Токен) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
МассивКалендарей = Новый Массив;
ПолучитьСписокКалендарейРекурсивно(Заголовки, МассивКалендарей);
Возврат МассивКалендарей;
КонецФункции
// Добавить календарь в список
// Добавляет существующий календарь в список пользователя
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ДобавитьКалендарьВСписок(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList";
Параметры = Новый Структура;
Параметры.Вставить("id", Календарь);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить календарь списка
// Получает календарь из списка пользователя по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьКалендарьСписка(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Календарь;
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Удалить календарь из списка
// Удаляет календарь из списка пользователя
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьКалендарьИзСписка(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Календарь;
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Изменить календарь списка
// Изменяет свойства календаря из списка пользователей
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// ОсновнойЦвет - Строка - HEX основного цвета (#ffffff) - primary
// ДополнительныйЦвет - Строка - HEX дополнительного цвета (#ffffff) - secondary
// Скрытый - Булево - Скрытый календарь - hidden
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ИзменитьКалендарьСписка(Знач Токен
@ -284,23 +284,23 @@
, Знач ОсновнойЦвет
, Знач ДополнительныйЦвет
, Знач Скрытый = Ложь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ОсновнойЦвет);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ДополнительныйЦвет);
OPI_ПреобразованиеТипов.ПолучитьБулево(Скрытый);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/users/me/calendarList/" + Календарь + "?colorRgbFormat=true";
Параметры = Новый Соответствие;
Параметры.Вставить("hidden" , Скрытый);
Параметры.Вставить("foregroundColor", ОсновнойЦвет);
Параметры.Вставить("backgroundColor", ДополнительныйЦвет);
Ответ = OPI_Инструменты.Put(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
@ -310,15 +310,15 @@
#Область РаботаССобытиями
// Получить описание события !NOCLI
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Пустой макет события
Функция ПолучитьОписаниеСобытия() Экспорт
ТекущаяДата = OPI_Инструменты.ПолучитьТекущуюДату();
Час = 3600;
Событие = Новый Соответствие;
Событие.Вставить("Описание" , ""); // Описание события
Событие.Вставить("Заголовок" , "Новое событие"); // Заголовок события
Событие.Вставить("МестоПроведения" , ""); // Строка описание места проведения
@ -328,149 +328,149 @@
Событие.Вставить("ОтправлятьУведомления" , Истина); // Признак отправки уведомлений участникам
Возврат Событие;
КонецФункции
// Получить список событий
// Получает список всех событий календаря
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Массив соответствий событий
Функция ПолучитьСписокСобытий(Знач Токен, Знач Календарь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
МассивСобытий = Новый Массив;
ПолучитьСписокСобытийРекурсивно(Заголовки, Календарь, МассивСобытий);
Возврат МассивСобытий;
КонецФункции
// Получить событие
// Получает событие по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// Событие - Строка - ID события - event
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьСобытие(Знач Токен, Знач Календарь, Знач Событие) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Событие);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
+ "/events/"
+ Событие;
+ Событие;
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Создать событие
// Создает новое событие
//
//
// Параметры:
// Токен - Строка - Токен - token
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// ОписаниеСобытия - Соответствие Из КлючИЗначение - Описание события - props
//
//
// Возвращаемое значение:
// Строка, Произвольный, HTTPОтвет, ДвоичныеДанные, Неопределено - ответ сервера Google
Функция СоздатьСобытие(Знач Токен, Знач Календарь, Знач ОписаниеСобытия) Экспорт
Функция СоздатьСобытие(Знач Токен, Знач Календарь, Знач ОписаниеСобытия) Экспорт
Возврат УправлениеСобытием(Токен, Календарь, ОписаниеСобытия);
КонецФункции
// Переместить событие
// Перемещает событие в другой календарь
//
//
// Параметры:
// Токен - Строка - Токен - token
// КалендарьИсточник - Строка - ID календаря источника - from
// КалендарьПриемник - Строка - ID календаря приемника - to
// Событие - Строка - ID события календаря источника - event
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПереместитьСобытие(Знач Токен, Знач КалендарьИсточник, Знач КалендарьПриемник, Знач Событие) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(КалендарьИсточник);
OPI_ПреобразованиеТипов.ПолучитьСтроку(КалендарьПриемник);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Событие);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ КалендарьИсточник
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ КалендарьИсточник
+ "/events/"
+ Событие
+ "/move?destination="
+ КалендарьПриемник;
+ КалендарьПриемник;
Ответ = OPI_Инструменты.Post(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Изменить событие
// Изменяет существующее событие
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// ОписаниеСобытия - Строка - Новое описание события - props
// Событие - Строка - ID события - event
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ИзменитьСобытие(Знач Токен, Знач Календарь, Знач ОписаниеСобытия, Знач Событие) Экспорт
Возврат УправлениеСобытием(Токен, Календарь, ОписаниеСобытия, Событие);
КонецФункции
// Удалить событие
// Удаляет событие по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Календарь - Строка - ID календаря - calendar
// Событие - Строка - ID события - event
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьСобытие(Знач Токен, Знач Календарь, Знач Событие) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Событие);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
+ "/events/"
+ Событие;
+ Событие;
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
@ -482,51 +482,51 @@
#Область СлужебныеПроцедурыИФункции
Функция ПреобразоватьДату(Знач Дата)
OPI_ПреобразованиеТипов.ПолучитьДату(Дата);
СтруктураДаты = Новый Структура;
Если Не ТипЗнч(Дата) = Тип("Дата") Тогда
Возврат Неопределено;
КонецЕсли;
Если Дата = НачалоДня(Дата) Тогда
Если Дата = НачалоДня(Дата) Тогда
ФорматДаты = "ДФ=yyyy-MM-dd";
Поле = "date";
Иначе
ФорматДаты = "ДФ=yyyy-MM-ddTHH:mm:ssZ";
Поле = "dateTime";
КонецЕсли;
Дата = Формат(Дата, ФорматДаты);
СтруктураДаты.Вставить(Поле , Дата);
СтруктураДаты.Вставить("timeZone", "Europe/Moscow");
Возврат СтруктураДаты;
КонецФункции
Функция ПреобразоватьВложения(Знач Вложения)
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(Вложения);
МассивВложений = Новый Массив;
Если ТипЗнч(Вложения) = Тип("Соответствие") Или ТипЗнч(Вложения) = Тип("Структура") Тогда
Для Каждого Вложение Из Вложения Цикл
ТекущеВложение = Новый Структура;
ТекущеВложение.Вставить("title" , Вложение.Ключ);
ТекущеВложение.Вставить("fileUrl", Вложение.Значение);
МассивВложений.Добавить(ТекущеВложение);
КонецЦикла;
КонецЕсли;
Если МассивВложений.Количество() > 0 Тогда
Возврат МассивВложений;
Иначе
@ -536,19 +536,19 @@
КонецФункции
Функция УправлениеСобытием(Знач Токен, Знач Календарь, Знач ОписаниеСобытия, Знач Событие = "")
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Календарь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Событие);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(ОписаниеСобытия);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
Существующее = ЗначениеЗаполнено(Событие);
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
URL = "https://www.googleapis.com/calendar/v3/calendars/"
+ Календарь
+ "/events"
+ ?(Существующее, "/" + Событие, "");
+ ?(Существующее, "/" + Событие, "");
Дата0 = ОписаниеСобытия["ДатаНачала"];
Дата1 = ОписаниеСобытия["ДатаОкончания"];
Вложения = ОписаниеСобытия["МассивURLФайловВложений"];
@ -556,85 +556,85 @@
Уведомления = ?(ОписаниеСобытия["ОтправлятьУведомления"] = Неопределено
, Ложь
, ОписаниеСобытия["ОтправлятьУведомления"]);
Параметры = Новый Структура;
Параметры.Вставить("summary" , ОписаниеСобытия["Заголовок"]);
Параметры.Вставить("description", ОписаниеСобытия["Описание"]);
Параметры.Вставить("location" , ОписаниеСобытия["МестоПроведения"]);
Параметры.Вставить("start" , ПреобразоватьДату(Дата0));
Параметры.Вставить("end" , ПреобразоватьДату(Дата1));
Параметры.Вставить("attachments", Вложения);
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("sendUpdates" , ?(Уведомления, "all", "none"));
Параметры.Вставить("attachments", Вложения);
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("sendUpdates" , ?(Уведомления , "all" , "none"));
ПараметрыURL.Вставить("supportsAttachments" , ?(ЗначениеЗаполнено(Вложения), "true", "false"));
URL = URL + OPI_Инструменты.ПараметрыЗапросаВСтроку(ПараметрыURL);
OPI_Инструменты.УдалитьПустыеПоляКоллекции(Параметры);
Если Существующее Тогда
Ответ = OPI_Инструменты.Patch(URL, Параметры, Заголовки, Истина);
Иначе
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки, Истина);
КонецЕсли;
Возврат Ответ;
КонецФункции
Процедура ПолучитьСписокКалендарейРекурсивно(Знач Заголовки, МассивКалендарей, Страница = "")
Процедура ПолучитьСписокКалендарейРекурсивно(Знач Заголовки, МассивКалендарей, Страница = "")
Items = "items";
NPT = "nextPageToken";
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Страница) Тогда
Параметры.Вставить("pageToken", Страница);
КонецЕсли;
Результат = OPI_Инструменты.Get("https://www.googleapis.com/calendar/v3/users/me/calendarList"
, Параметры
, Заголовки);
Календари = Результат[Items];
Страница = Результат[NPT];
Для Каждого Календарь Из Календари Цикл
МассивКалендарей.Добавить(Календарь);
КонецЦикла;
МассивКалендарей.Добавить(Календарь);
КонецЦикла;
Если Календари.Количество() > 0 И ЗначениеЗаполнено(Страница) Тогда
ПолучитьСписокКалендарейРекурсивно(Заголовки, МассивКалендарей, Страница);
ПолучитьСписокКалендарейРекурсивно(Заголовки, МассивКалендарей, Страница);
КонецЕсли;
КонецПроцедуры
Процедура ПолучитьСписокСобытийРекурсивно(Знач Заголовки, Знач Календарь, МассивСобытий, Страница = "")
Процедура ПолучитьСписокСобытийРекурсивно(Знач Заголовки, Знач Календарь, МассивСобытий, Страница = "")
Items = "items";
NPT = "nextPageToken";
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Страница) Тогда
Параметры.Вставить("pageToken", Страница);
КонецЕсли;
Результат = OPI_Инструменты.Get("https://www.googleapis.com/calendar/v3/calendars/" + Календарь + "/events"
, Параметры
, Заголовки);
События = Результат[Items];
Страница = Результат[NPT];
Для Каждого Событие Из События Цикл
МассивСобытий.Добавить(Событие);
КонецЦикла;
МассивСобытий.Добавить(Событие);
КонецЦикла;
Если События.Количество() > 0 И ЗначениеЗаполнено(Страница) Тогда
ПолучитьСписокСобытийРекурсивно(Заголовки, МассивСобытий, Страница);
ПолучитьСписокСобытийРекурсивно(Заголовки, МассивСобытий, Страница);
КонецЕсли;
КонецПроцедуры
#КонецОбласти
#КонецОбласти

424
src/ru/OPI/src/CommonModules/OPI_GoogleDrive/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/core/Modules/OPI_GoogleDrive.os
// OneScript: ./OInt/core/Modules/OPI_GoogleDrive.os
// Lib: Google Drive
// CLI: gdrive
@ -43,277 +43,277 @@
// Получить информацию об объекте
// Получает информацию о папке или файле по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор файла или каталога - object
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьИнформациюОбОбъекте(Знач Токен, Знач Идентификатор) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
Параметры = Новый Структура;
Параметры.Вставить("fields", "*");
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить список каталогов
// Получает список каталогов диска
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИмяСодержит - Строка - Отбор по имени - querry
// Подробно - Булево - Добавляет список файлов к полям каталога - depth
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Массив соответствий каталогов
Функция ПолучитьСписокКаталогов(Знач Токен, Знач ИмяСодержит = "", Знач Подробно = Ложь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИмяСодержит);
OPI_ПреобразованиеТипов.ПолучитьБулево(Подробно);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
МассивОбъектов = Новый Массив;
Отбор = Новый Массив;
Отбор.Добавить("mimeType = 'application/vnd.google-apps.folder'");
Если ЗначениеЗаполнено(ИмяСодержит) Тогда
Отбор.Добавить("name contains '" + ИмяСодержит + "'");
КонецЕсли;
ПолучитьСписокОбъектовРекурсивно(Заголовки, МассивОбъектов, Подробно, Отбор);
Если Подробно Тогда
РазложитьОбъектыПодробно(Токен, МассивОбъектов);
РазложитьОбъектыПодробно(Токен, МассивОбъектов);
КонецЕсли;
Возврат МассивОбъектов;
КонецФункции
// Получить список файлов
// Получает список файлов
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИмяСодержит - Строка - Отбор по имени - querry
// Каталог - Строка - Отбор по ID каталога родителя - catalog
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Массив соответствий файлов
Функция ПолучитьСписокФайлов(Знач Токен, Знач ИмяСодержит = "", Знач Каталог = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИмяСодержит);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Каталог);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
МассивОбъектов = Новый Массив;
Отбор = Новый Массив;
Отбор.Добавить("mimeType != 'application/vnd.google-apps.folder'");
Если ЗначениеЗаполнено(ИмяСодержит) Тогда
Отбор.Добавить("name contains '" + ИмяСодержит + "'");
КонецЕсли;
Если ЗначениеЗаполнено(Каталог) Тогда
Отбор.Добавить("'" + Каталог + "' in parents");
КонецЕсли;
ПолучитьСписокОбъектовРекурсивно(Заголовки, МассивОбъектов, , Отбор);
Возврат МассивОбъектов;
КонецФункции
// Загрузить файл
// Загружает файл на диск
//
//
// Параметры:
// Токен - Строка - Токен - token
// Файл - ДвоичныеДанные,Строка - Загружаемый файл - file
// Описание - Соответствие Из КлючИЗначение - См. ПолучитьОписаниеФайла - props - JSON описания или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ЗагрузитьФайл(Знач Токен, Знач Файл, Знач Описание) Экспорт
Возврат УправлениеФайлом(Токен, Файл, Описание);
Возврат УправлениеФайлом(Токен, Файл, Описание);
КонецФункции
// Создать папку
// Создает пустой каталог на диске
//
//
// Параметры:
// Токен - Строка - Токен - token
// Имя - Строка - Имя папки - title
// Родитель - Строка - Родитель - catalog
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция СоздатьПапку(Знач Токен, Знач Имя, Знач Родитель = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Имя);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Родитель);
Описание = Новый Соответствие;
Описание.Вставить("MIME" , "application/vnd.google-apps.folder");
Описание.Вставить("Имя" , Имя);
Описание.Вставить("Описание", "");
Описание.Вставить("Родитель", ?(ЗначениеЗаполнено(Родитель), Родитель, "root"));
Возврат УправлениеФайлом(Токен, , Описание);
КонецФункции
// Скачать файл
// Получает файл по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор файла - object
// ПутьСохранения - Строка - Путь сохранения файла - out
//
// ПутьСохранения - Строка - Путь сохранения файла - out
//
// Возвращаемое значение:
// ДвоичныеДанные,Строка - Двоичные данные или путь к файлу при указании параметра ПутьСохранения
Функция СкачатьФайл(Знач Токен, Знач Идентификатор, Знач ПутьСохранения = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
Параметры = Новый Соответствие;
Параметры.Вставить("alt", "media");
Ответ = OPI_Инструменты.Get(URL, Параметры , Заголовки, ПутьСохранения);
Возврат Ответ;
КонецФункции
// Скоприровать объект
// Копирует файл или каталог
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор объекта - object
// НовоеИмя - Строка - Новое имя объекта - title
// НовыйРодитель - Строка - Новый каталог размещения - catalog
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция СкопироватьОбъект(Знач Токен, Знач Идентификатор, Знач НовоеИмя = "", Знач НовыйРодитель = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(НовоеИмя);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
OPI_ПреобразованиеТипов.ПолучитьСтроку(НовыйРодитель);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор + "/copy";
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор + "/copy";
Параметры = Новый Структура;
Если ЗначениеЗаполнено(НовоеИмя) Тогда
Параметры.Вставить("name", НовоеИмя);
КонецЕсли;
Если ЗначениеЗаполнено(НовыйРодитель) Тогда
МассивРодителей = Новый Массив;
МассивРодителей.Добавить(НовыйРодитель);
Параметры.Вставить("parents", МассивРодителей);
КонецЕсли;
Ответ = OPI_Инструменты.Post(URL, Параметры , Заголовки, Истина);
Возврат Ответ;
КонецФункции
// Обновить файл
// Обновляет двоичные данные файла
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор обновляемого объекта - object
// Файл - ДвоичныеДанные,Строка - Файл источник обновления - file
// НовоеИмя - Строка - Новое имя файла (если необходимо) - title
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ОбновитьФайл(Знач Токен, Знач Идентификатор, Знач Файл, Знач НовоеИмя = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
OPI_ПреобразованиеТипов.ПолучитьСтроку(НовоеИмя);
OPI_ПреобразованиеТипов.ПолучитьДвоичныеДанные(Файл);
Если ЗначениеЗаполнено(НовоеИмя) Тогда
Описание = Новый Соответствие;
Описание.Вставить("Имя", НовоеИмя);
Иначе
Описание = "";
КонецЕсли;
Возврат УправлениеФайлом(Токен, Файл, Описание, Идентификатор);
КонецФункции
// Удалить объект
// Удаляет файл или каталог по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор объекта для удаления - object
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьОбъект(Знач Токен, Знач Идентификатор) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор;
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Получить описание файла !NOCLI
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - Описание файла
Функция ПолучитьОписаниеФайла() Экспорт
Описание = Новый Соответствие;
Описание.Вставить("MIME" , "image/jpeg"); // MIME-тип загружаемого файла
Описание.Вставить("Имя" , "Новый файл.jpg"); // Имя файла с расширением
Описание.Вставить("Описание" , "Это новый файл"); // Описание файла
Описание.Вставить("Родитель" , "root"); // ID каталога загрузки или "root" для загрузки в корень
Возврат Описание;
КонецФункции
#КонецОбласти
@ -322,107 +322,107 @@
// Создать комментарий
// Создает комментарий к файлу или каталогу
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор объекта, для которого необходим комментарий - object
// Идентификатор - Строка - Идентификатор объекта, для которого необходим комментарий - object
// Комментарий - Строка - Текст комментария - text
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция СоздатьКомментарий(Знач Токен, Знач Идентификатор, Знач Комментарий) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Комментарий);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор + "/comments?fields=*";
URL = "https://www.googleapis.com/drive/v3/files/" + Идентификатор + "/comments?fields=*";
Параметры = Новый Структура;
Параметры.Вставить("content", Комментарий);
Ответ = OPI_Инструменты.POST(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить комментарий
// Получает комментарий по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИДОбъекта - Строка - Идентификатор файла или каталога размещения комментария - object
// ИДКомментария - Строка - Идентификатор комментария - comment
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьКомментарий(Знач Токен, Знач ИДОбъекта, Знач ИДКомментария) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИДОбъекта);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИДКомментария);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments/" + ИДКомментария;
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments/" + ИДКомментария;
Параметры = Новый Структура;
Параметры.Вставить("fields", "*");
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить список комментариев
// Получает список всех комментариев объекта
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИДОбъекта - Строка - Идентификатор объекта - object
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьСписокКомментариев(Знач Токен, Знач ИДОбъекта) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИДОбъекта);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments";
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments";
Параметры = Новый Структура;
Параметры.Вставить("fields", "*");
Ответ = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Удалить комментарий
// Удаляет комментарий по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИДОбъекта - Строка - Идентификатор файла или каталога размещения комментария - object
// ИДКомментария - Строка - Идентификатор комментария - comment
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьКомментарий(Знач Токен, Знач ИДОбъекта, Знач ИДКомментария) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИДОбъекта);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ИДКомментария);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments/" + ИДКомментария;
URL = "https://www.googleapis.com/drive/v3/files/" + ИДОбъекта + "/comments/" + ИДКомментария;
Ответ = OPI_Инструменты.Delete(URL, , Заголовки);
Возврат Ответ;
КонецФункции
@ -433,59 +433,59 @@
#Область СлужебныеПроцедурыИФункции
Процедура ПолучитьСписокОбъектовРекурсивно(Знач Заголовки, МассивОбъектов, Подробно = Ложь, Отбор = "", Страница = "")
Процедура ПолучитьСписокОбъектовРекурсивно(Знач Заголовки, МассивОбъектов, Подробно = Ложь, Отбор = "", Страница = "")
URL = "https://www.googleapis.com/drive/v3/files";
Files = "files";
NPT = "nextPageToken";
Параметры = Новый Структура;
Параметры.Вставить("fields", "*");
Если ЗначениеЗаполнено(Страница) Тогда
Параметры.Вставить("pageToken", Страница);
КонецЕсли;
Если ЗначениеЗаполнено(Отбор) И ТипЗнч(Отбор) = Тип("Массив") Тогда
Если ЗначениеЗаполнено(Отбор) И ТипЗнч(Отбор) = Тип("Массив") Тогда
ОтборСтрока = СтрСоединить(Отбор, " and ");
Параметры.Вставить("q", ОтборСтрока);
Параметры.Вставить("q", ОтборСтрока);
КонецЕсли;
Результат = OPI_Инструменты.Get(URL, Параметры, Заголовки);
Объекты = Результат[Files];
Страница = Результат[NPT];
Для Каждого ТекущийОбъект Из Объекты Цикл
МассивОбъектов.Добавить(ТекущийОбъект);
КонецЦикла;
КонецЦикла;
Если Объекты.Количество() > 0 И ЗначениеЗаполнено(Страница) Тогда
ПолучитьСписокОбъектовРекурсивно(Заголовки, МассивОбъектов, Подробно, Отбор, Страница);
ПолучитьСписокОбъектовРекурсивно(Заголовки, МассивОбъектов, Подробно, Отбор, Страница);
КонецЕсли;
КонецПроцедуры
Процедура РазложитьОбъектыПодробно(Знач Токен, МассивОбъектов)
Процедура РазложитьОбъектыПодробно(Знач Токен, МассивОбъектов)
Для Каждого ТекущийОбъект Из МассивОбъектов Цикл
МассивФайлов = Новый Массив;
ТекущийИД = ТекущийОбъект["id"];
Результат = ПолучитьСписокФайлов(Токен, , ТекущийИД);
Для Каждого Файл Из Результат Цикл
МассивФайлов.Добавить(Файл);
МассивФайлов.Добавить(Файл);
КонецЦикла;
ТекущийОбъект.Вставить("files", МассивФайлов);
КонецЦикла;
КонецПроцедуры
Процедура СформироватьПараметрыЗагрузкиФайла(Описание)
СформированноеОписание = Новый Соответствие;
OPI_Инструменты.УдалитьПустыеПоляКоллекции(Описание);
@ -495,81 +495,81 @@
СоответствиеПолей.Вставить("Описание" , "description");
СоответствиеПолей.Вставить("Родитель" , "parents");
СоответствиеПолей.Вставить("Расширение", "fileExtension");
Для Каждого Элемент Из Описание Цикл
Если Элемент.Ключ = "Родитель" Тогда
ТекущееЗначение = Новый Массив;
ТекущееЗначение.Добавить(Элемент.Значение);
Иначе
ТекущееЗначение = Элемент.Значение;
КонецЕсли;
ИмяПоля = СоответствиеПолей.Получить(Элемент.Ключ);
СформированноеОписание.Вставить(ИмяПоля, ТекущееЗначение);
КонецЦикла;
Описание = СформированноеОписание;
КонецПроцедуры
Функция УправлениеФайлом(Знач Токен, Знач Файл = "", Знач Описание = "", Знач Идентификатор = "")
Функция УправлениеФайлом(Знач Токен, Знач Файл = "", Знач Описание = "", Знач Идентификатор = "")
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
Если ЗначениеЗаполнено(Описание) Тогда
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(Описание);
КонецЕсли;
MimeType = "mimeType";
Если ЗначениеЗаполнено(Идентификатор) Тогда
MIME = ПолучитьИнформациюОбОбъекте(Токен, Идентификатор)[MimeType];
Иначе
MIME = Описание["MIME"];
КонецЕсли;
КонецЕсли;
Если Не ЗначениеЗаполнено(Описание) Тогда
Описание = Новый Соответствие;
КонецЕсли;
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
СформироватьПараметрыЗагрузкиФайла(Описание);
ОписаниеJSON = OPI_Инструменты.JSONСтрокой(Описание);
СоответствиеФайла = Новый Соответствие;
Если ЗначениеЗаполнено(Файл) Тогда
РазмерЧасти = 268435457;
РазмерЧасти = 268435457;
Размер = OPI_Инструменты.ПреобразоватьДанныеСПолучениемРазмера(Файл, РазмерЧасти);
СоответствиеФайла.Вставить(Файл, MIME);
Если Размер < РазмерЧасти И ТипЗнч(Файл) = Тип("ДвоичныеДанные") Тогда
Ответ = ЗагрузитьМалыйФайл(ОписаниеJSON, СоответствиеФайла, Заголовки, Идентификатор);
Иначе
Ответ = ЗагрузитьБольшойФайл(Описание, СоответствиеФайла, Заголовки, Идентификатор);
КонецЕсли;
Иначе
Ответ = ЗагрузитьМалыйФайл(ОписаниеJSON, СоответствиеФайла, Заголовки, Идентификатор);
Ответ = ЗагрузитьМалыйФайл(ОписаниеJSON, СоответствиеФайла, Заголовки, Идентификатор);
КонецЕсли;
Возврат Ответ;
КонецФункции
Функция ЗагрузитьМалыйФайл(Знач Описание, Знач СоответствиеФайла, Знач Заголовки, Знач Идентификатор = "")
URL = "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart";
Если ЗначениеЗаполнено(Идентификатор) Тогда
URL = СтрЗаменить(URL, "/files", "/files/" + Идентификатор);
Ответ = OPI_Инструменты.PatchMultipartRelated(URL, Описание, СоответствиеФайла, Заголовки);
@ -578,149 +578,149 @@
КонецЕсли;
Возврат Ответ;
КонецФункции
Функция ЗагрузитьБольшойФайл(Знач Описание, Знач СоответствиеФайла, Знач Заголовки, Знач Идентификатор = "")
Для Каждого Файл Из СоответствиеФайла Цикл
Двоичные = Файл.Ключ;
Прервать;
КонецЦикла;
URL = "https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable";
Если ЗначениеЗаполнено(Идентификатор) Тогда
URL = СтрЗаменить(URL, "/files", "/files/" + Идентификатор);
Ответ = OPI_Инструменты.Patch(URL, Описание, Заголовки, Истина, Истина);
Иначе
Ответ = OPI_Инструменты.Post(URL, Описание, Заголовки, Истина, Истина);
КонецЕсли;
АдресЗагрузки = Ответ.Заголовки["Location"];
Если Не ЗначениеЗаполнено(АдресЗагрузки) Тогда
OPI_Инструменты.ОбработатьОтвет(Ответ);
Возврат Ответ;
КонецЕсли;
ОтветЗагрузки = ЗагрузитьФайлЧастями(Двоичные, АдресЗагрузки);
Ответ = ?(ЗначениеЗаполнено(ОтветЗагрузки), ОтветЗагрузки, Ответ);
OPI_Инструменты.ОбработатьОтвет(Ответ);
Возврат Ответ;
КонецФункции
Функция ЗагрузитьФайлЧастями(Знач Двоичные, Знач АдресЗагрузки)
Ответ = "";
РазмерЧасти = 268435456;
ПрочитаноБайт = 0;
Ответ = "";
РазмерЧасти = 268435456;
ПрочитаноБайт = 0;
ТекущаяПозиция = 0;
ОбщийРазмер = Двоичные.Размер();
СтрОбщийРазмер = OPI_Инструменты.ЧислоВСтроку(ОбщийРазмер);
ЧтениеДанных = Новый ЧтениеДанных(Двоичные);
ИсходныйПоток = ЧтениеДанных.ИсходныйПоток();
Пока ПрочитаноБайт < ОбщийРазмер Цикл
ПрочитаноБайт = ИсходныйПоток.ТекущаяПозиция();
Результат = ЧтениеДанных.Прочитать(РазмерЧасти);
ТекущиеДанные = Результат.ПолучитьДвоичныеДанные();
РазмерТекущих = ТекущиеДанные.Размер();
СледующаяПозиция = ТекущаяПозиция + РазмерТекущих - 1;
СледующаяПозиция = ТекущаяПозиция + РазмерТекущих - 1;
Если Не ЗначениеЗаполнено(ТекущиеДанные) Тогда
Прервать;
КонецЕсли;
ЗаголовокПотока = "bytes "
+ OPI_Инструменты.ЧислоВСтроку(ТекущаяПозиция)
+ "-"
+ OPI_Инструменты.ЧислоВСтроку(СледующаяПозиция)
+ "/"
+ "-"
+ OPI_Инструменты.ЧислоВСтроку(СледующаяПозиция)
+ "/"
+ СтрОбщийРазмер;
ДопЗаголовки = Новый Соответствие;
ДопЗаголовки.Вставить("Content-Length", OPI_Инструменты.ЧислоВСтроку(РазмерТекущих));
ДопЗаголовки.Вставить("Content-Range" , ЗаголовокПотока);
ДопЗаголовки.Вставить("Content-Range" , ЗаголовокПотока);
ДопЗаголовки.Вставить("Content-Type" , "application/octet-stream");
Ответ = OPI_Инструменты.Put(АдресЗагрузки, ТекущиеДанные, ДопЗаголовки, Ложь, Истина);
РезультатПроверки = ПроверитьЗагрузкуЧасти(Ответ, СтрОбщийРазмер, ДопЗаголовки, АдресЗагрузки, ТекущаяПозиция);
Если ЗначениеЗаполнено(РезультатПроверки) Тогда
Возврат РезультатПроверки;
КонецЕсли;
// !OInt КБайт = 1024;
// !OInt МБайт = КБайт * КБайт;
// !OInt Сообщить(OPI_Инструменты.ИнформацияОПрогрессе(ТекущаяПозиция, ОбщийРазмер, "МБ", МБайт));
// !OInt ВыполнитьСборкуМусора();
// !OInt ОсвободитьОбъект(ТекущиеДанные);
КонецЦикла;
Возврат Ответ;
КонецФункции
Функция ПроверитьЗагрузкуЧасти(Ответ, СтрОбщийРазмер, ДопЗаголовки, АдресЗагрузки, ТекущаяПозиция)
НачалоКодовОшибок = 400;
КонецКодовПадений = 600;
НачалоКодовУспеха = 200;
КонецКодовУспеха = 300;
Перенаправление = 308;
Если Ответ.КодСостояния >= НачалоКодовОшибок И Ответ.КодСостояния < КонецКодовПадений Тогда
ЗаголовокПотока = "bytes */" + СтрОбщийРазмер;
ДопЗаголовки.Вставить("Content-Range" , ЗаголовокПотока);
ОтветПроверки = OPI_Инструменты.Put(АдресЗагрузки, "", ДопЗаголовки, Ложь, Истина);
Если ОтветПроверки.КодСостояния >= НачалоКодовУспеха И ОтветПроверки.КодСостояния < КонецКодовУспеха Тогда
OPI_Инструменты.ОбработатьОтвет(ОтветПроверки);
Возврат ОтветПроверки;
ИначеЕсли ОтветПроверки.КодСостояния = Перенаправление Тогда
ЗагруженныеДанные = Ответ.Заголовки["Range"];
Иначе
OPI_Инструменты.ОбработатьОтвет(Ответ);
Возврат Ответ;
КонецЕсли;
Иначе
ЗагруженныеДанные = Ответ.Заголовки["Range"];
КонецЕсли;
Если Не ЗначениеЗаполнено(ЗагруженныеДанные) Тогда
OPI_Инструменты.ОбработатьОтвет(Ответ);
Возврат Ответ;
КонецЕсли;
ЗагруженныеДанные = СтрЗаменить(ЗагруженныеДанные, "bytes=", "");
МассивИнформации = СтрРазделить(ЗагруженныеДанные, "-", Ложь);
НеобходимоЧастей = 2;
Если Не МассивИнформации.Количество() = НеобходимоЧастей Тогда
OPI_Инструменты.ОбработатьОтвет(Ответ);
Возврат Ответ;
КонецЕсли;
ТекущаяПозиция = Число(МассивИнформации[1]) + 1;
Возврат "";
КонецФункции
#КонецОбласти

212
src/ru/OPI/src/CommonModules/OPI_GoogleSheets/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/core/Modules/OPI_GoogleSheets.os
// OneScript: ./OInt/core/Modules/OPI_GoogleSheets.os
// Lib: Google Sheets
// CLI: gsheets
@ -43,90 +43,90 @@
// Создать книгу
// Создает новую книгу
//
//
// Параметры:
// Токен - Строка - Токен - token
// Наименование - Строка - Наименование - title
// МассивИменЛистов - Массив из Строка - Массив имен для добавления новых листов в книгу - sheets
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция СоздатьКнигу(Знач Токен, Знач Наименование, Знач МассивИменЛистов) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивИменЛистов);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets";
Свойства = Новый Структура("title" , Наименование);
Листы = Новый Массив;
ЗаполнитьМассивЛистов(МассивИменЛистов, Листы);
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("properties", Свойства, "Коллекция", Параметры);
OPI_Инструменты.ДобавитьПоле("sheets" , Листы , "Коллекция", Параметры);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить книгу
// Получает информацию о книге по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// Идентификатор - Строка - Идентификатор книги - spreadsheet
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьКнигу(Знач Токен, Знач Идентификатор) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Идентификатор);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Идентификатор;
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
// Изменить наименование книги
// Изменяет наименование существующей книги
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - ID книги - spreadsheet
// Наименование - Строка - Новое наименование - title
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ИзменитьНаименованиеКниги(Знач Токен, Знач Книга, Знач Наименование) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + ":batchUpdate";
Изменение = Новый Структура("title", Наименование);
ЗапросИзменения = Новый Структура("properties,fields", Изменение, "title");
Запрос = Новый Структура("updateSpreadsheetProperties", ЗапросИзменения);
МассивЗапросов = Новый Массив;
МассивЗапросов.Добавить(Запрос);
Параметры = Новый Структура("requests", МассивЗапросов);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -135,95 +135,95 @@
// Добавить лист
// Добавляет новый лист в книгу
//
//
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - Идентификатор книги - spreadsheet
// Наименование - Строка - Наименование нового листа - title
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ДобавитьЛист(Знач Токен, Знач Книга, Знач Наименование) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + ":batchUpdate";
Лист = СоздатьЛист(Наименование);
Запросы = Новый Массив;
Изменение = Новый Структура("addSheet", Лист);
Запросы.Добавить(Изменение);
Параметры = Новый Структура("requests", Запросы);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Удалить лист
// Удаляет лист из книги
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - Идентификатор книги - spreadsheet
// Лист - Строка - Идентификатор удаляемого листа - sheet
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УдалитьЛист(Знач Токен, Знач Книга, Знач Лист) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Лист);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + ":batchUpdate";
Запросы = Новый Массив;
Лист = Новый Структура("sheetId" , Лист);
Изменение = Новый Структура("deleteSheet", Лист);
Запросы.Добавить(Изменение);
Параметры = Новый Структура("requests", Запросы);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Копировать лист
// Копирует лист из одной книги в другую
//
//
// Параметры:
// Токен - Строка - Токен - token
// Откуда - Строка - ID книги источника - from
// Куда - Строка - ID книги приемника - to
// Лист - Строка - ID копируемого листа - sheet
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция КопироватьЛист(Знач Токен, Знач Откуда, Знач Куда, Знач Лист) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Откуда);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Куда);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Лист);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/"
+ Откуда
+ "/sheets/"
+ Лист
+ ":copyTo";
Параметры = Новый Структура("destinationSpreadsheetId", Куда);
Параметры = Новый Структура("destinationSpreadsheetId", Куда);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -232,14 +232,14 @@
// Установить значения ячеек
// Устанавливает значения ячеек листа
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - ID книги - spreadsheet
// Книга - Строка - ID книги - spreadsheet
// СоответствиеЗначений - Соответствие Из КлючИЗначение - Данные заполнения, где ключ это имя ячейки вида A1 - data
// Лист - Строка - Имя листа (первый лист по умолчанию) - sheetname
// ОсновноеИзмерение - Строка - Основное измерение при заполнении диапазона массивом - dim
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция УстановитьЗначенияЯчеек(Знач Токен
@ -247,90 +247,90 @@
, Знач СоответствиеЗначений
, Знач Лист = ""
, Знач ОсновноеИзмерение = "COLUMNS") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(СоответствиеЗначений);
Если Не ТипЗнч(СоответствиеЗначений) = Тип("Структура")
Если Не ТипЗнч(СоответствиеЗначений) = Тип("Структура")
И Не ТипЗнч(СоответствиеЗначений) = Тип("Соответствие") Тогда
Возврат "Не удалось привести структуру значений к коллекции";
КонецЕсли;
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + "/values:batchUpdate";
МассивДанных = СформироватьМассивДанныхЯчеек(СоответствиеЗначений, ОсновноеИзмерение, Лист);
Параметры = Новый Структура("data,valueInputOption", МассивДанных, "USER_ENTERED");
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Очистить ячейки
// Очищает значение в ячейках
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - ID книги - spreadsheet
// МассивЯчеек - Массив из Строка - Массив ячеек вида А1 для очистки - cells
// Лист - Строка - Имя листа (первый лист по умолчанию) - sheetname
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ОчиститьЯчейки(Знач Токен, Знач Книга, Знач МассивЯчеек, Знач Лист = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивЯчеек);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + "/values:batchClear";
СформироватьМассивИменЯчеек(МассивЯчеек, Лист);
Параметры = Новый Структура("ranges", МассивЯчеек);
Ответ = OPI_Инструменты.Post(URL, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить значения ячеек
// Получает значения ячеек таблицы
//
//
// Параметры:
// Токен - Строка - Токен - token
// Книга - Строка - ID книги - spreadsheet
// МассивЯчеек - Массив из Строка - Массив ячеек вида А1 для получения (весь лист, если не заполнено) - cells
// Лист - Строка - Имя листа (первый лист по умолчанию) - sheetname
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьЗначенияЯчеек(Знач Токен, Знач Книга, Знач МассивЯчеек = "", Знач Лист = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Книга);
Заголовки = OPI_GoogleWorkspace.ПолучитьЗаголовокАвторизации(Токен);
URL = "https://sheets.googleapis.com/v4/spreadsheets/" + Книга + "/values:batchGet";
Если ЗначениеЗаполнено(МассивЯчеек) Тогда
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивЯчеек);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивЯчеек);
СформироватьМассивИменЯчеек(МассивЯчеек, Лист);
Первый = Истина;
Первый = Истина;
Для Каждого Ячейка Из МассивЯчеек Цикл
Разделитель = ?(Первый, "?", "&");
URL = URL + Разделитель + "ranges=" + Ячейка;
Первый = Ложь;
КонецЦикла;
Иначе
URL = URL + "?ranges='" + Лист + "'";
URL = URL + "?ranges ='" + Лист + "'";
КонецЕсли;
Ответ = OPI_Инструменты.Get(URL, , Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -340,75 +340,75 @@
#Область СлужебныеПроцедурыИФункции
Процедура ЗаполнитьМассивЛистов(Знач МассивИмен, МассивЛистов)
Для Каждого ИмяЛиста Из МассивИмен Цикл
Лист = СоздатьЛист(ИмяЛиста);
МассивЛистов.Добавить(Лист);
КонецЦикла;
КонецПроцедуры
Процедура ДобавитьИмяЛиста(Ячейка, Знач Лист)
Если ЗначениеЗаполнено(Лист) Тогда
Ячейка = "'" + Лист + "'!" + Ячейка;
КонецЕсли;
КонецПроцедуры
Функция СоздатьЛист(Знач Наименование)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Наименование);
СвойстваЛиста = Новый Структура("title" , Наименование);
Лист = Новый Структура("properties", СвойстваЛиста);
Возврат Лист;
КонецФункции
Функция СформироватьМассивДанныхЯчеек(Знач СтруктураЗначений, Знач ОсновноеИзмерение, Знач Лист)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Лист);
МассивДанных = Новый Массив;
Для Каждого ДанныеЯчейки Из СтруктураЗначений Цикл
ТекущееЗначение = ДанныеЯчейки.Значение;
ТекущийКлюч = ДанныеЯчейки.Ключ;
ДобавитьИмяЛиста(ТекущийКлюч, Лист);
OPI_ПреобразованиеТипов.ПолучитьМассив(ТекущееЗначение);
ТекущиеДанные = Новый Соответствие;
ТекущийМассив = Новый Массив;
ТекущийМассив.Добавить(ТекущееЗначение);
OPI_Инструменты.ДобавитьПоле("range" , ТекущийКлюч , "Строка", ТекущиеДанные);
OPI_Инструменты.ДобавитьПоле("values" , ТекущийМассив , "Массив", ТекущиеДанные);
OPI_Инструменты.ДобавитьПоле("majorDimension", ОсновноеИзмерение, "Строка", ТекущиеДанные);
МассивДанных.Добавить(ТекущиеДанные);
КонецЦикла;
Возврат МассивДанных;
КонецФункции
Процедура СформироватьМассивИменЯчеек(Знач МассивИмен, Знач Лист)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Лист);
Для Н = 0 По МассивИмен.ВГраница() Цикл
OPI_ПреобразованиеТипов.ПолучитьСтроку(Лист);
Для Н = 0 По МассивИмен.ВГраница() Цикл
ДобавитьИмяЛиста(МассивИмен[Н], Лист);
КонецЦикла;
КонецПроцедуры
#КонецОбласти
#КонецОбласти

72
src/ru/OPI/src/CommonModules/OPI_GoogleWorkspace/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/core/Modules/OPI_GoogleWorkspace.os
// OneScript: ./OInt/core/Modules/OPI_GoogleWorkspace.os
// Lib: Google Workspace
// CLI: google
@ -41,97 +41,97 @@
// Сформировать ссылку получения кода
// Возвращает URL для авторизации в браузере
//
//
// Параметры:
// ClientID - Строка - Client ID - id
// Calendar - Булево - разрешение на методы Calendar - calendar
// Drive - Булево - разрешение на методы Drive - drive
// Sheets - Булево - разрешение на методы Sheets - sheets
//
//
// Возвращаемое значение:
// Строка - Ссылка получения кода
Функция СформироватьСсылкуПолученияКода(Знач ClientID
, Знач Calendar = Истина
, Знач Drive = Истина
, Знач Sheets = Истина) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientID);
OPI_ПреобразованиеТипов.ПолучитьБулево(Calendar);
OPI_ПреобразованиеТипов.ПолучитьБулево(Sheets);
OPI_ПреобразованиеТипов.ПолучитьБулево(Drive);
URL = "https://accounts.google.com/o/oauth2/auth";
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("response_type", "code");
ПараметрыURL.Вставить("client_id" , ClientID);
ПараметрыURL.Вставить("redirect_uri" , "http://localhost");
ПараметрыURL.Вставить("access_type" , "offline");
ПараметрыURL.Вставить("scope" , ПолучитьСписокРазрешений(Calendar, Drive, Sheets));
URL = URL + OPI_Инструменты.ПараметрыЗапросаВСтроку(ПараметрыURL);
Возврат URL;
КонецФункции
// Получить токен по коду
// Получает токен по коду из авторизации в бразуере
//
//
// Параметры:
// ClientID - Строка - Client ID - id
// ClientSecret - Строка - Client secret - secret
// Code - Строка - Code из браузера - code
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ПолучитьТокенПоКоду(Знач ClientID, Знач ClientSecret, Знач Code) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientID);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientSecret);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Code);
URL = "https://accounts.google.com/o/oauth2/token";
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("grant_type" , "authorization_code");
ПараметрыURL.Вставить("client_id" , ClientID);
ПараметрыURL.Вставить("client_secret", ClientSecret);
ПараметрыURL.Вставить("redirect_uri" , "http://localhost");
ПараметрыURL.Вставить("redirect_uri" , "http://localhost");
ПараметрыURL.Вставить("code" , Code);
Ответ = OPI_Инструменты.Post(URL, ПараметрыURL, , Ложь);
Возврат Ответ;
КонецФункции
// Обновить токен
// Обновляет токен по Refresh token
//
//
// Параметры:
// ClientID - Строка - Client ID - id
// ClientSecret - Строка - Client secret - secret
// RefreshToken - Строка - Refresh token - refresh
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Google
Функция ОбновитьТокен(Знач ClientID, Знач ClientSecret, Знач RefreshToken) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientID);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientSecret);
OPI_ПреобразованиеТипов.ПолучитьСтроку(RefreshToken);
URL = "https://accounts.google.com/o/oauth2/token";
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("grant_type" , "refresh_token");
ПараметрыURL.Вставить("client_id" , ClientID);
ПараметрыURL.Вставить("client_secret", ClientSecret);
ПараметрыURL.Вставить("client_secret", ClientSecret);
ПараметрыURL.Вставить("refresh_token", RefreshToken);
Ответ = OPI_Инструменты.Post(URL, ПараметрыURL, , Ложь);
Возврат Ответ;
КонецФункции
@ -141,14 +141,14 @@
#Область СлужебныйПрограммныйИнтерфейс
Функция ПолучитьЗаголовокАвторизации(Знач Токен) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
Заголовки = Новый Соответствие;
Заголовки.Вставить("Authorization", "Bearer " + Токен);
Возврат Заголовки;
КонецФункции
#КонецОбласти
@ -156,23 +156,23 @@
#Область СлужебныеПроцедурыИфункции
Функция ПолучитьСписокРазрешений(Calendar, Drive, Sheets)
МассивРазрешений = Новый Массив;
Если Calendar Тогда
МассивРазрешений.Добавить("https://www.googleapis.com/auth/calendar");
КонецЕсли;
Если Drive Тогда
МассивРазрешений.Добавить("https://www.googleapis.com/auth/drive");
КонецЕсли;
Если Sheets Тогда
МассивРазрешений.Добавить("https://www.googleapis.com/auth/spreadsheets");
КонецЕсли;
Возврат СтрСоединить(МассивРазрешений, " ");
КонецФункции
#КонецОбласти
#КонецОбласти

514
src/ru/OPI/src/CommonModules/OPI_Notion/Module.bsl
View File

File diff suppressed because it is too large Load Diff

500
src/ru/OPI/src/CommonModules/OPI_Slack/Module.bsl
View File

File diff suppressed because it is too large Load Diff

492
src/ru/OPI/src/CommonModules/OPI_Telegram/Module.bsl
View File

File diff suppressed because it is too large Load Diff

408
src/ru/OPI/src/CommonModules/OPI_Twitter/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/core/Modules/OPI_Twitter.os
// OneScript: ./OInt/core/Modules/OPI_Twitter.os
// Lib: Twitter
// CLI: twitter
@ -48,18 +48,18 @@
// Получить ссылку для авторизации
// Формирует ссылку для авторизации через браузер
//
//
// Параметры:
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Строка - URL для перехода в браузере
Функция ПолучитьСсылкуАвторизации(Параметры = "") Экспорт
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
ПараметрыURL = Новый Структура;
ПараметрыURL.Вставить("response_type" , "code");
ПараметрыURL.Вставить("client_id" , Параметры_["client_id"]);
ПараметрыURL.Вставить("redirect_uri" , Параметры_["redirect_uri"]);
@ -67,27 +67,27 @@
ПараметрыURL.Вставить("state" , "state");
ПараметрыURL.Вставить("code_challenge" , "challenge");
ПараметрыURL.Вставить("code_challenge_method", "plain");
ПараметрыURL = OPI_Инструменты.ПараметрыЗапросаВСтроку(ПараметрыURL);
Линк = "https://twitter.com/i/oauth2/authorize" + ПараметрыURL;
Линк = "https://twitter.com/i/oauth2/authorize" + ПараметрыURL;
Возврат Линк;
КонецФункции
// Получить токен
// Получает токен по коду, полученному при авторизации по ссылке из ПолучитьСсылкуАвторизации
//
//
// Параметры:
// Код - Строка - Код, полученный из авторизации См.ПолучитьСсылкуАвторизации - code
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция ПолучитьТокен(Знач Код, Знач Параметры = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Код);
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
ПараметрыЗапроса = Новый Структура;
@ -96,35 +96,35 @@
ПараметрыЗапроса.Вставить("client_id" , Параметры_["client_id"]);
ПараметрыЗапроса.Вставить("redirect_uri" , Параметры_["redirect_uri"]);
ПараметрыЗапроса.Вставить("code_verifier", "challenge");
Ответ = OPI_Инструменты.Post("https://api.twitter.com/2/oauth2/token"
, ПараметрыЗапроса, , Ложь);
Возврат Ответ;
КонецФункции
// Обновить токен
// Обновить токен
// Обновляет v2 токен при помощи refresh_token
//
//
// Параметры:
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция ОбновитьТокен(Знач Параметры = "") Экспорт
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
Refresh = "refresh_token";
ПараметрыЗапроса = Новый Структура;
ПараметрыЗапроса.Вставить(Refresh , Параметры_[Refresh]);
ПараметрыЗапроса.Вставить("grant_type" , Refresh);
ПараметрыЗапроса.Вставить("client_id" , Параметры_["client_id"]);
Ответ = OPI_Инструменты.Post("https://api.twitter.com/2/oauth2/token"
, ПараметрыЗапроса, , Ложь);
Возврат Ответ;
КонецФункции
@ -133,23 +133,23 @@
// Метод для вставки в http-сервис, адрес которого указывается в redirect_uri
// Вызывает метод получения токена, так как для получения токена из кода, приходящего
// на redirect_uri после авторизации через браузер есть всего 30 секунд
//
//
// Параметры:
// Запрос - HTTPСервисЗапрос - Запрос, приходящий на http-сервис
//
//
// Возвращаемое значение:
// HTTPОтвет, Произвольный, ДвоичныеДанные - Результат чтения JSON ответа сервера
Функция ОбработкаВходящегоЗапросаПослеАвторизации(Запрос) Экспорт
Код = Запрос.ПараметрыЗапроса["code"];
Код = Запрос.ПараметрыЗапроса["code"];
ОтветТокен = ПолучитьТокен(Код);
// BSLLS:CommentedCode-off
// Предпочтительное хранение токенов
// Константы.TwitterRefresh.Установить(ОтветТокен["refresh_token"]);
// Константы.TwitterToken.Установить(ОтветТокен["access_token"]);
// BSLLS:CommentedCode-on
Возврат ОтветТокен;
КонецФункции
@ -160,189 +160,189 @@
// !NOCLI
// Создать произвольный твит
//
//
// Параметры:
// Текст - Строка - Текст твита
// МассивМедиа - Массив из Строка,ДвоичныеДанные - Массив двоичных данных или путей к файлам
// МассивВариантовОпроса - Массив из Строка - Массив вариантов опроса, если необходимо
// ДлительностьОпроса - Строка,Число - Длительность опроса, если необходимо (опрос без длительности не создается)
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьПроизвольныйТвит(Знач Текст = ""
, Знач МассивМедиа = ""
, Знач МассивВариантовОпроса = ""
, Знач ДлительностьОпроса = ""
, Знач Параметры = "") Экспорт
, Знач Параметры = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Текст);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ДлительностьОпроса);
Если ЗначениеЗаполнено(МассивМедиа) Тогда
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивМедиа);
КонецЕсли;
Если ЗначениеЗаполнено(МассивВариантовОпроса) Тогда
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивВариантовОпроса);
КонецЕсли;
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
URL = "https://api.twitter.com/2/tweets";
Массив = "Массив";
Массив = "Массив";
Поля = Новый Соответствие;
Если ЗначениеЗаполнено(Текст) Тогда
Поля.Вставить("text", Текст);
КонецЕсли;
Если ТипЗнч(МассивВариантовОпроса) = Тип(Массив) И ЗначениеЗаполнено(ДлительностьОпроса) Тогда
ДлительностьОпроса = Число(ДлительностьОпроса);
Если МассивВариантовОпроса.Количество() > 0 Тогда
СтруктураВарианта = Новый Структура("options,duration_minutes", МассивВариантовОпроса, ДлительностьОпроса);
Поля.Вставить("poll", СтруктураВарианта);
КонецЕсли;
КонецЕсли;
Если ТипЗнч(МассивМедиа) = Тип(Массив) Тогда
Если МассивМедиа.Количество() > 0 Тогда
Поля.Вставить("media", Новый Структура("media_ids", МассивМедиа));
КонецЕсли;
КонецЕсли;
Авторизация = СоздатьЗаголовокАвторизацииV2(Параметры_);
Ответ = OPI_Инструменты.Post(URL, Поля, Авторизация);
Возврат Ответ;
КонецФункции
// Создать текстовый твит
// Создает твит без вложений
//
//
// Параметры:
// Текст - Строка - Текст твита - text
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьТекстовыйТвит(Знач Текст, Знач Параметры = "") Экспорт
Возврат СоздатьПроизвольныйТвит(Текст, , , , Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, , , , Параметры);
КонецФункции
// Создать твит картинки
// Создает твит с картинкой вложением
//
//
// Параметры:
// Текст - Строка - Текст твита - text
// МассивКартинок - Массив из Строка,ДвоичныеДанные - Массив файлов картинок - pictures
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьТвитКартинки(Знач Текст, Знач МассивКартинок, Знач Параметры = "") Экспорт
МассивМедиа = ЗагрузитьМассивВложений(МассивКартинок, "photo", Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, МассивМедиа, , , Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, МассивМедиа, , , Параметры);
КонецФункции
// Создать твит гифки
// Создает твит с вложением-гифкой
//
//
// Параметры:
// Текст - Строка - Текст твита - text
// МассивГифок - Массив из Строка,ДвоичныеДанные - Массив файлов гифок - gifs
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьТвитГифки(Знач Текст, Знач МассивГифок, Знач Параметры = "") Экспорт
МассивМедиа = ЗагрузитьМассивВложений(МассивГифок, "animated_gif", Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, МассивМедиа, , , Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, МассивМедиа, , , Параметры);
КонецФункции
// Создать твит видео
// Создает твит с видеовложением
//
//
// Параметры:
// Текст - Строка - Текст твита - text
// МассивВидео - Массив из Строка,ДвоичныеДанные - Массив файлов видео - videos
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьТвитВидео(Знач Текст, Знач МассивВидео, Знач Параметры = "") Экспорт
МассивМедиа = ЗагрузитьМассивВложений(МассивВидео, "video", Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, МассивМедиа, , , Параметры);
КонецФункции
// Создать твит опрос
// Создает твит с опросом
//
//
// Параметры:
// Текст - Строка - Текст твита - text
// МассивВариантов - Массив из Строка - Массив вариантов опроса - options
// Длительность - Строка,Число - Длительность опроса - duration
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Twitter
Функция СоздатьТвитОпрос(Знач Текст, Знач МассивВариантов, Знач Длительность, Знач Параметры = "") Экспорт
Возврат СоздатьПроизвольныйТвит(Текст, , МассивВариантов, Длительность, Параметры);
Возврат СоздатьПроизвольныйТвит(Текст, , МассивВариантов, Длительность, Параметры);
КонецФункции
// Загрузить массив вложений !NOCLI
// Загружает файлы на сервер и возвращает их ID
//
//
// Параметры:
// МассивФайлов - Массив из Строка, ДвоичныеДанные - Массив файлов
// ТипВложений - Строка - Тип вложений
// Параметры - Структура из Строка - См.ПолучитьСтандартныеПараметры - auth - JSON авторизации или путь к .json
//
//
// Возвращаемое значение:
// Массив Из Строка - Массив ID медиа
Функция ЗагрузитьМассивВложений(Знач МассивФайлов, Знач ТипВложений, Знач Параметры = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ТипВложений);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивФайлов);
МассивМедиа = Новый Массив;
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
MIS = "media_id_string";
Если ЗначениеЗаполнено(МассивФайлов) Тогда
Для Каждого ФайлОтправки Из МассивФайлов Цикл
OPI_ПреобразованиеТипов.ПолучитьДвоичныеДанные(ФайлОтправки);
Ответ = ЗагрузитьМедиафайл(ФайлОтправки, ТипВложений, Параметры_);
IDМедиа = Ответ[MIS];
Если Не ЗначениеЗаполнено(IDМедиа) Тогда
Возврат Ответ;
КонецЕсли;
МассивМедиа.Добавить(IDМедиа);
КонецЦикла;
КонецЕсли;
Возврат МассивМедиа;
КонецФункции
#КонецОбласти
@ -351,70 +351,70 @@
#Область СлужебныеПроцедурыИФункции
Функция ЗагрузитьМедиафайл(Знач Файл, Знач Тип, Знач Параметры)
Функция ЗагрузитьМедиафайл(Знач Файл, Знач Тип, Знач Параметры)
OPI_ПреобразованиеТипов.ПолучитьДвоичныеДанные(Файл);
ВидЗапроса = "POST";
ВидЗапроса = "POST";
Параметры_ = ПолучитьСтандартныеПараметры(Параметры);
URL = "https://upload.twitter.com/1.1/media/upload.json";
Если Тип = "photo" Тогда
Если Тип = "photo" Тогда
Поля = Новый Структура;
Поля.Вставить("media_data" , Base64Строка(Файл));
Поля.Вставить("media_category", Тип);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры_, Поля, ВидЗапроса, URL);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры_, Поля, ВидЗапроса, URL);
Ответ = OPI_Инструменты.Post(URL, Поля, Авторизация, Ложь);
Иначе
Ответ = ЗагрузитьМедиаЧастями(Файл, Тип, ВидЗапроса, URL, Параметры_);
КонецЕсли;
Возврат Ответ;
КонецФункции
Функция ЗагрузитьМедиаЧастями(Знач Файл, Знач Тип, Знач ВидЗапроса, Знач URL, Параметры)
Единица = 1024;
Количество = 4;
MediaKey = "media_key";
MIS = "media_id_string";
Command = "command";
Размер = Файл.Размер();
СоответствиеMIME = Новый Соответствие;
СоответствиеMIME.Вставить("photo" , "image/jpeg");
СоответствиеMIME.Вставить("video" , "video/mp4");
СоответствиеMIME.Вставить("animated_gif", "image/gif");
РазмерЧасти = Количество * Единица * Единица;
МассивЧтения = РазделитьДвоичныеДанные(Файл, РазмерЧасти);
Поля = Новый Структура;
Поля.Вставить(Command , "INIT");
Поля.Вставить("total_bytes" , OPI_Инструменты.ЧислоВСтроку(Размер));
Поля.Вставить("media_type" , СоответствиеMIME.Получить(Тип));
Поля.Вставить("media_category" , Тип);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Поля, ВидЗапроса, URL);
ОтветИнициализации = OPI_Инструменты.Post(URL, Поля, Авторизация, Ложь);
KeyИнициализации = ОтветИнициализации[MediaKey];
IDИнициализации = ОтветИнициализации[MIS];
Если Не ЗначениеЗаполнено(KeyИнициализации) Или Не ЗначениеЗаполнено(IDИнициализации) Тогда
Возврат ОтветИнициализации;
Возврат ОтветИнициализации;
КонецЕсли;
Счетчик = 0;
Для Каждого Часть Из МассивЧтения Цикл
Поля = Новый Структура;
Поля.Вставить(Command , "APPEND");
Поля.Вставить("media_key" , KeyИнициализации);
@ -422,111 +422,111 @@
Поля.Вставить("media" , Часть);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Новый Структура, ВидЗапроса, URL);
OPI_Инструменты.PostMultipart(URL, Поля, , , Авторизация);
Счетчик = Счетчик + 1;
КонецЦикла;
Поля = Новый Структура;
Поля.Вставить(Command , "FINALIZE");
Поля.Вставить("media_id", IDИнициализации);
СтатусОбработки = ПолучитьСтатусОбработки(Параметры, Поля, URL);
Если Не ТипЗнч(СтатусОбработки) = Тип("Строка") Тогда
Возврат СтатусОбработки;
КонецЕсли;
Ответ = ОжидатьЗавершенияОбработки(СтатусОбработки, IDИнициализации, URL, Параметры);
Возврат Ответ;
КонецФункции
Функция ОжидатьЗавершенияОбработки(Знач СтатусОбработки, Знач IDИнициализации, Знач URL, Знач Параметры)
ProcessingInfo = "processing_info";
Command = "command";
Поля = Новый Структура;
Поля.Вставить(Command , "STATUS");
Поля.Вставить("media_id", IDИнициализации);
Пока Строка(СтатусОбработки) = "pending" Или Строка(СтатусОбработки) = "in_progress" Цикл
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Поля, "GET", URL);
Ответ = OPI_Инструменты.Get(URL, Поля, Авторизация);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Поля, "GET", URL);
Ответ = OPI_Инструменты.Get(URL, Поля, Авторизация);
Информация = Ответ[ProcessingInfo];
Если Не ЗначениеЗаполнено(Информация) Тогда
Возврат Ответ;
КонецЕсли;
СтатусОбработки = Информация["state"];
Если Не ЗначениеЗаполнено(СтатусОбработки) Тогда
Возврат Ответ;
КонецЕсли;
КонецЦикла;
Если СтатусОбработки = "failed" Тогда
ВызватьИсключение "Твиттер не смог обработать загруженное вами видео";
КонецЕсли;
Возврат Ответ;
КонецФункции
Функция ПолучитьСтандартныеПараметры(Знач Параметры = "")
// Здесь собрано определение данных, необходимых для работы.
// Для Twitter это довольно значительный набор, что обсуловлено наличием сразу 2-х API,
// которые, при этом, созданы не для разныз задач, но просто являются версиями друг друга.
// Актуальной версией API является v2 и она требует получения временных токенов. Несмотря на то,
// что Twitter настаивает на использовании этой актуальной версии, они как-то умудрились не перенести
// механизм загрузки файлов и некоторые другие из старой версии - v1.1. Поэтому что-то нужно делать
// механизм загрузки файлов и некоторые другие из старой версии - v1.1. Поэтому что-то нужно делать
// на версии 1.1, а что-то на 2: вплоть до того что они убрали возможность постить твиты из v1.1,
// но только через нее в твит можно добавить картинку. При этом способы авторизации и токены у них разные
// Мировая гигокорпорация Илона Маска, кстати, напоминаю ;)
// P.S Далее часто упоминается "страница настроек Twitter Developer" - это
// P.S Далее часто упоминается "страница настроек Twitter Developer" - это
// https://developer.twitter.com/en/portal/dashboard и выбор конкретного проекта из списка (значек c ключем)
Параметры_ = Новый Соответствие;
Параметры_ = Новый Соответствие;
Разрешения = "tweet.read tweet.write tweet.moderate.write users.read "
+ "follows.read follows.write offline.access space.read mute.read "
+ "mute.write like.read like.write list.read list.write block.read "
+ "block.write bookmark.read bookmark.write";
+ "block.write bookmark.read bookmark.write";
// Данные для API v2
// redirect_uri - URL вашего http-сервиса (или другого обработчика запросов) для авторизации
// scope - набор разрешений для получаемого ключа. Может быть любой, но offline.access обязателен
// client_id - Из OAuth 2.0 Client ID and Client Secret страницы настроек Twitter Developer
// client_secret - Из OAuth 2.0 Client ID and Client Secret страницы настроек Twitter Developer
// access_token - ПолучитьСсылкуАвторизации() -> Браузер -> code придет на redirect_uri -> ПолучитьТокен(code)
// refresh_token - Приходит вместе с access_token и используется для его обновления (время жизни access_token - 2 ч)
// Обновление происходит методом ОбновитьТокен с новыми access_token и refresh_token.
// При следующем обновлении нужно использовать уже новый refresh_token, так что захардкодить
// не получится (access_token тоже не получится)
// Обновление происходит методом ОбновитьТокен с новыми access_token и refresh_token.
// При следующем обновлении нужно использовать уже новый refresh_token, так что захардкодить
// не получится (access_token тоже не получится)
// |--> ОбновитьТокен() ->|access_token --> Используется в т-нии 2-х часов для запросов
// | |refresh_token --|
// |--------[через 2 ч.]-------------------|
// Данные для API v1.1
// oauth_token - Из Authentication Tokens -> Access Token and Secret страницы настроек Twitter Developer
// oauth_token - Из Authentication Tokens -> Access Token and Secret страницы настроек Twitter Developer
// oauth_token_secret - Из Authentication Tokens -> Access Token and Secret страницы настроек Twitter Developer
// oauth_consumer_key - Из Consumer Keys -> Access Token and Secret страницы настроек Twitter Developer
// oauth_consumer_secret - Из Consumer Keys -> Access Token and Secret страницы настроек Twitter Developer
// Эти токены обновлять не надо
Параметры_.Вставить("redirect_uri" , "");
Параметры_.Вставить("scope" , Разрешения);
Параметры_.Вставить("client_id" , "");
@ -537,9 +537,9 @@
Параметры_.Вставить("oauth_token_secret" , "");
Параметры_.Вставить("oauth_consumer_key" , "");
Параметры_.Вставить("oauth_consumer_secret", "");
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(Параметры);
Если ТипЗнч(Параметры) = Тип("Структура") Или ТипЗнч(Параметры) = Тип("Соответствие") Тогда
Для Каждого ПереданныйПараметр Из Параметры Цикл
Параметры_.Вставить(ПереданныйПараметр.Ключ, OPI_Инструменты.ЧислоВСтроку(ПереданныйПараметр.Значение));
@ -551,7 +551,7 @@
КонецФункции
Функция СоздатьЗаголовокАвторизацииV1(Знач Параметры, Знач Поля, Знач ВидЗапроса, Знач URL)
ТекущаяДата = OPI_Инструменты.ПолучитьТекущуюДату();
ЗаголовокАвторизации = "";
МетодХэширования = "HMAC-SHA1";
@ -565,123 +565,123 @@
ТаблицаПараметров = Новый ТаблицаЗначений;
ТаблицаПараметров.Колонки.Добавить("Ключ");
ТаблицаПараметров.Колонки.Добавить("Значение");
Для Каждого Поле Из Поля Цикл
НоваяСтрока = ТаблицаПараметров.Добавить();
Для Каждого Поле Из Поля Цикл
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = Поле.Ключ;
НоваяСтрока.Значение = Поле.Значение;
КонецЦикла;
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = OCK;
НоваяСтрока.Значение = Параметры[OCK];
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = OTK;
НоваяСтрока.Значение = Параметры[OTK];
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = "oauth_version";
НоваяСтрока.Значение = ВерсияАпи;
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = "oauth_signature_method";
НоваяСтрока.Значение = МетодХэширования;
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = "oauth_timestamp";
НоваяСтрока.Значение = ТекущаяДатаUNIX;
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока = ТаблицаПараметров.Добавить();
НоваяСтрока.Ключ = "oauth_nonce";
НоваяСтрока.Значение = ТекущаяДатаUNIX;
Для Каждого СтрокаТаблицы Из ТаблицаПараметров Цикл
СтрокаТаблицы.Ключ = КодироватьСтроку(СтрокаТаблицы.Ключ, СпособКодированияСтроки.КодировкаURL);
СтрокаТаблицы.Значение = КодироватьСтроку(СтрокаТаблицы.Значение, СпособКодированияСтроки.КодировкаURL);
КонецЦикла;
ТаблицаПараметров.Сортировать("Ключ");
Для Каждого СтрокаТаблицы Из ТаблицаПараметров Цикл
СтрокаСигнатуры = СтрокаСигнатуры
+ СтрокаТаблицы.Ключ
+ "="
СтрокаСигнатуры = СтрокаСигнатуры
+ СтрокаТаблицы.Ключ
+ " ="
+ СтрокаТаблицы.Значение
+ "&";
КонецЦикла;
СтрокаСигнатуры = Лев(СтрокаСигнатуры, СтрДлина(СтрокаСигнатуры) - 1);
СтрокаСигнатуры = вРег(ВидЗапроса)
+ "&"
+ КодироватьСтроку(URL, СпособКодированияСтроки.КодировкаURL)
СтрокаСигнатуры = вРег(ВидЗапроса)
+ "&"
+ КодироватьСтроку(URL , СпособКодированияСтроки.КодировкаURL)
+ "&"
+ КодироватьСтроку(СтрокаСигнатуры, СпособКодированияСтроки.КодировкаURL);
Подпись = КодироватьСтроку(Параметры["oauth_consumer_secret"], СпособКодированияСтроки.КодировкаURL)
+ "&"
+ "&"
+ КодироватьСтроку(Параметры["oauth_token_secret"], СпособКодированияСтроки.КодировкаURL);
Сигнатура = OPI_Криптография.HMAC(ПолучитьДвоичныеДанныеИзСтроки(Подпись)
, ПолучитьДвоичныеДанныеИзСтроки(СтрокаСигнатуры)
, ХешФункция.SHA1
, 64);
Сигнатура = КодироватьСтроку(Base64Строка(Сигнатура), СпособКодированияСтроки.КодировкаURL);
Разделитель = """,";
ЗаголовокАвторизации = ЗаголовокАвторизации
Разделитель = """,";
ЗаголовокАвторизации = ЗаголовокАвторизации
+ "OAuth "
+ "oauth_consumer_key=""" + Параметры[OCK] + Разделитель
+ "oauth_token=""" + Параметры[OTK] + Разделитель
+ "oauth_consumer_key =""" + Параметры[OCK] + Разделитель
+ "oauth_token =""" + Параметры[OTK] + Разделитель
+ "oauth_signature_method=""" + МетодХэширования + Разделитель
+ "oauth_timestamp=""" + ТекущаяДатаUNIX + Разделитель
+ "oauth_nonce=""" + ТекущаяДатаUNIX + Разделитель
+ "oauth_version=""" + ВерсияАпи + Разделитель
+ "oauth_signature=""" + Сигнатура;
+ "oauth_timestamp =""" + ТекущаяДатаUNIX + Разделитель
+ "oauth_nonce =""" + ТекущаяДатаUNIX + Разделитель
+ "oauth_version =""" + ВерсияАпи + Разделитель
+ "oauth_signature =""" + Сигнатура;
СоответствиеЗаголовка = Новый Соответствие;
СоответствиеЗаголовка.Вставить("authorization", ЗаголовокАвторизации);
Возврат СоответствиеЗаголовка;
КонецФункции
Функция СоздатьЗаголовокАвторизацииV2(Знач Параметры)
СоответствиеВозврата = Новый Соответствие;
СоответствиеВозврата.Вставить("Authorization", "Bearer " + Параметры["access_token"]);
Возврат СоответствиеВозврата;
КонецФункции
Функция ПолучитьСтатусОбработки(Знач Параметры, Знач Поля, Знач URL)
ProcessingInfo = "processing_info";
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Поля, "POST", URL);
Ответ = OPI_Инструменты.Post(URL, Поля, Авторизация, Ложь);
Авторизация = СоздатьЗаголовокАвторизацииV1(Параметры, Поля, "POST", URL);
Ответ = OPI_Инструменты.Post(URL, Поля, Авторизация, Ложь);
Информация = Ответ[ProcessingInfo];
Если Не ЗначениеЗаполнено(Информация) Тогда
Возврат Ответ;
КонецЕсли;
СтатусОбработки = Информация["state"];
Если Не ЗначениеЗаполнено(СтатусОбработки) Тогда
Возврат Ответ;
Иначе
Возврат СтатусОбработки;
КонецЕсли;
КонецЕсли;
КонецФункции
#КонецОбласти

1252
src/ru/OPI/src/CommonModules/OPI_VK/Module.bsl
View File

File diff suppressed because it is too large Load Diff

202
src/ru/OPI/src/CommonModules/OPI_Viber/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/core/Modules/OPI_Viber.os
// OneScript: ./OInt/core/Modules/OPI_Viber.os
// Lib: Viber
// CLI: viber
@ -23,7 +23,7 @@
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
// https://github.com/Bayselonarrend/OpenIntegrations
// BSLLS:LatinAndCyrillicSymbolInWord-off
@ -46,55 +46,55 @@
// который будет возвращать 200 и подлинный SSL сертификат. Если есть сертификат и база опубликована
// на сервере - можно использовать http-сервис. Туда же будет приходить и информация о новых сообщениях
// Viber периодически стучит по адресу Webhook, так что если он будет неактивен, то все перестанет работать
//
//
// Параметры:
// Токен - Строка - Токен Viber - token
// URL - Строка - URL для установки Webhook - url
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция УстановитьWebhook(Знач Токен, Знач URL) Экспорт
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("url" , URL , "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("auth_token" , Токен, "Строка", Параметры);
Возврат OPI_Инструменты.Post("https://chatapi.viber.com/pa/set_webhook", Параметры);
КонецФункции
// Получить информацию о канале
// Тут можно получить ID пользователей канала. ID для бота необходимо получать из прилетов на Webhook
// ID пользователя из информации о канале не подойдет для отправки сообщений через бота - они разные
//
//
// Параметры:
// Токен - Строка - Токен - token
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ПолучитьИнформациюОКанале(Знач Токен) Экспорт
URL = "https://chatapi.viber.com/pa/get_account_info";
URL = "https://chatapi.viber.com/pa/get_account_info";
Возврат OPI_Инструменты.Get(URL, , ТокенВЗаголовки(Токен));
КонецФункции
// Получить данные пользователя
// Получает информацию о пользователе по ID
//
//
// Параметры:
// Токен - Строка - Токен - token
// IDПользователя - Строка, Число - ID пользователя Viber - user
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ПолучитьДанныеПользователя(Знач Токен, Знач IDПользователя) Экспорт
URL = "https://chatapi.viber.com/pa/get_user_details";
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("id", IDПользователя, "Строка", Параметры);
Ответ = OPI_Инструменты.Post(URL, Параметры, ТокенВЗаголовки(Токен));
Возврат Ответ;
@ -103,22 +103,22 @@
// Получить онлайн пользователей
// Получает статус пользователя или нескольких пользователей по ID
//
//
// Параметры:
// Токен - Строка - Токен Viber - token
// IDПользователей - Строка,Число,Массив из Строка,Число - ID пользователей(я) Viber - users
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ПолучитьОнлайнПользователей(Знач Токен, Знач IDПользователей) Экспорт
URL = "https://chatapi.viber.com/pa/get_online";
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("ids", IDПользователей, "Коллекция", Параметры);
Ответ = OPI_Инструменты.Post(URL, Параметры, ТокенВЗаголовки(Токен));
Возврат Ответ;
КонецФункции
@ -129,14 +129,14 @@
// Отправить текстовое сообщение
// Отправляет текстовое сообщение в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// Текст - Строка - Текст сообщения - text
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - Булево - Отправка в канал или в чат бота - ischannel
// Клавиатура - Структура из Строка - См. СформироватьКлавиатуруИзМассиваКнопок - keyboard
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьТекстовоеСообщение(Знач Токен
@ -144,40 +144,40 @@
, Знач IDПользователя
, Знач ОтправкаВКанал
, Знач Клавиатура = "") Экспорт
Возврат ОтправитьСообщение(Токен, "text", IDПользователя, ОтправкаВКанал, , Текст, Клавиатура);
Возврат ОтправитьСообщение(Токен, "text", IDПользователя, ОтправкаВКанал, , Текст, Клавиатура);
КонецФункции
// Отправить картинку
// Отправляет картинку в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - URL картинки - picture
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - булево - Отправка в канал или в чат бота - ischannel
// Описание - Строка - Аннотация к картинке - description
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьКартинку(Знач Токен, Знач URL, Знач IDПользователя, Знач ОтправкаВКанал, Знач Описание = "") Экспорт
Возврат ОтправитьСообщение(Токен, "picture", IDПользователя, ОтправкаВКанал, URL, Описание);
КонецФункции
// Отправить файл
// Отправляет файл (документ) в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - URL файла - file
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// URL - Строка - URL файла - file
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - Булево - Отправка в канал или в чат бота - ischannel
// Расширение - Строка - Расширение файла - ext
// Размер - Число - Размер файла. Если не заполнен > определяется автоматически скачиванием файла - size
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьФайл(Знач Токен
@ -186,36 +186,36 @@
, Знач ОтправкаВКанал
, Знач Расширение
, Знач Размер = "") Экспорт
Если Не ЗначениеЗаполнено(Размер) Тогда
Ответ = OPI_Инструменты.Get(URL);
Размер = Ответ.Размер();
КонецЕсли;
Строка_ = "Строка";
Расширение = СтрЗаменить(Расширение, ".", "");
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("URL" , URL , Строка_, Параметры);
OPI_Инструменты.ДобавитьПоле("Размер" , Размер , Строка_, Параметры);
OPI_Инструменты.ДобавитьПоле("Расширение", Расширение, Строка_, Параметры);
Возврат ОтправитьСообщение(Токен, "file", IDПользователя, ОтправкаВКанал, Параметры);
КонецФункции
// Отправить контакт
// Отправляет контакт с номером телефона в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// ИмяКонтакта - Строка - Имя контакта - name
// НомерТелефона - Строка - Номер телефона - phone
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - Булево - Отправка в канал или в чат бота - ischannel
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьКонтакт(Знач Токен
@ -223,91 +223,91 @@
, Знач НомерТелефона
, Знач IDПользователя
, Знач ОтправкаВКанал) Экспорт
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("name" , ИмяКонтакта , "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("phone_number", НомерТелефона, "Строка", Параметры);
Возврат ОтправитьСообщение(Токен, "contact", IDПользователя, ОтправкаВКанал, Параметры);
Возврат ОтправитьСообщение(Токен, "contact", IDПользователя, ОтправкаВКанал, Параметры);
КонецФункции
// Отправить локацию
// Отправляет географические координаты в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// Широта - Строка,Число - Географическая широта - lat
// Долгота - Строка,Число - Географическая долгота - long
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - Булево - Отправка в канал или в чат бота - ischannel
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьЛокацию(Знач Токен, Знач Широта, Знач Долгота, Знач IDПользователя, Знач ОтправкаВКанал) Экспорт
Параметры = Новый Структура;
OPI_Инструменты.ДобавитьПоле("lat", Широта , "Строка", Параметры);
OPI_Инструменты.ДобавитьПоле("lon", Долгота, "Строка", Параметры);
Возврат ОтправитьСообщение(Токен, "location", IDПользователя, ОтправкаВКанал, Параметры);
КонецФункции
// Отправить ссылку
// Отправляет URL с предпросмотром в чат или канал
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - Отправляемая ссылка - url
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// IDПользователя - Строка,Число - ID пользователя. Для канала > администратора, для бота > получателя - user
// ОтправкаВКанал - Булево - Отправка в канал или в чат бота - ischannel
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Viber
Функция ОтправитьСсылку(Знач Токен, Знач URL, Знач IDПользователя, Знач ОтправкаВКанал) Экспорт
Возврат ОтправитьСообщение(Токен, "url", IDПользователя, ОтправкаВКанал, URL);
КонецФункции
// Сформировать клавиатуру из массива кнопок
// Возвращает структура клавиатуры для сообщений
//
//
// Параметры:
// МассивКнопок - Массив из Строка - Массив кнопок - buttons
// ЦветКнопок - Строка - HEX цвет кнопок с # в начале - color
//
//
// Возвращаемое значение:
// Структура - Сформировать клавиатуру из массива кнопок:
// * Buttons - Массив из Структура - Массив сформированных кнопок
// * Type - Строка - Тип клавиатуры
// * Buttons - Массив из Структура - Массив сформированных кнопок
// * Type - Строка - Тип клавиатуры
Функция СформироватьКлавиатуруИзМассиваКнопок(Знач МассивКнопок, Знач ЦветКнопок = "#2db9b9") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ЦветКнопок);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(МассивКнопок);
МассивСтруктурКнопок = Новый Массив;
СтруктураКлавиатуры = Новый Структура;
Для Каждого ТекстКнопки Из МассивКнопок Цикл
СтруктураКнопки = Новый Структура;
СтруктураКнопки.Вставить("ActionType", "reply");
СтруктураКнопки.Вставить("ActionBody", ТекстКнопки);
СтруктураКнопки.Вставить("Text" , ТекстКнопки);
СтруктураКнопки.Вставить("BgColor" , ЦветКнопок);
СтруктураКнопки.Вставить("Coloumns" , 3);
МассивСтруктурКнопок.Добавить(СтруктураКнопки);
КонецЦикла;
СтруктураКлавиатуры.Вставить("Buttons", МассивСтруктурКнопок);
СтруктураКлавиатуры.Вставить("Type" , "keyboard");
Возврат СтруктураКлавиатуры;
КонецФункции
#КонецОбласти
@ -317,7 +317,7 @@
#Область СлужебныеПроцедурыИФункции
// Отправить сообщение.
//
//
// Параметры:
// Токен - Строка - Токен
// Тип - Строка - Тип отправляемого сообщения
@ -328,8 +328,8 @@
// * Размер - Число, Строка - Размер файла в случае отправке
// * Расширение - Строка - Расширение файла в случае отправки
// Текст - Строка - Текст сообщения
// Клавиатура - Структура из Строка - Клавиатура, если нужна, см. СформироватьКлавиатуруИзМассиваКнопок
//
// Клавиатура - Структура из Строка - Клавиатура, если нужна, см. СформироватьКлавиатуруИзМассиваКнопок
//
// Возвращаемое значение:
// Произвольный, HTTPОтвет - Отправить сообщение
Функция ОтправитьСообщение(Знач Токен
@ -339,28 +339,28 @@
, Знач Значение = ""
, Знач Текст = ""
, Знач Клавиатура = "")
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Тип);
OPI_ПреобразованиеТипов.ПолучитьСтроку(IDПользователя);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Текст);
OPI_ПреобразованиеТипов.ПолучитьБулево(ЭтоКанал);
OPI_ПреобразованиеТипов.ПолучитьКоллекцию(Клавиатура);
СтруктураПараметров = ВернутьСтандартныеПараметры();
СтруктураПараметров.Вставить("type", Тип);
СтруктураПараметров.Вставить("type", Тип);
Если (Тип = "text" Или Тип = "picture") И ЗначениеЗаполнено(Текст) Тогда
СтруктураПараметров.Вставить("text", Текст);
КонецЕсли;
Если ТипЗнч(Клавиатура) = Тип("Структура") Тогда
СтруктураПараметров.Вставить("keyboard", Клавиатура);
КонецЕсли;
Если ЗначениеЗаполнено(Значение) Тогда
Если Тип = "file" Тогда
Если Тип = "file" Тогда
СтруктураПараметров.Вставить("media" , Значение["URL"]);
СтруктураПараметров.Вставить("size" , Значение["Размер"]);
СтруктураПараметров.Вставить("file_name", "Файл." + Значение["Расширение"]);
@ -371,49 +371,49 @@
Иначе
СтруктураПараметров.Вставить("media" , Значение);
КонецЕсли;
КонецЕсли;
Если ЭтоКанал Тогда
СтруктураПараметров.Вставить("from", IDПользователя);
СтруктураПараметров.Вставить("from" , IDПользователя);
URL = "https://chatapi.viber.com/pa/post";
Иначе
Иначе
СтруктураПараметров.Вставить("receiver", IDПользователя);
URL = "https://chatapi.viber.com/pa/send_message";
КонецЕсли;
Ответ = OPI_Инструменты.Post(URL, СтруктураПараметров, ТокенВЗаголовки(Токен));
Попытка
Возврат OPI_Инструменты.JsonВСтруктуру(Ответ.ПолучитьТелоКакДвоичныеДанные());
Исключение
Возврат Ответ;
КонецПопытки;
КонецФункции
Функция ВернутьСтандартныеПараметры()
Функция ВернутьСтандартныеПараметры()
СтруктураОтправителя = Новый Структура;
СтруктураОтправителя.Вставить("name" , "Bot");
СтруктураОтправителя.Вставить("avatar", "");
СтруктураПараметров = Новый Структура;
СтруктураПараметров.Вставить("sender", СтруктураОтправителя);
СтруктураПараметров.Вставить("sender" , СтруктураОтправителя);
СтруктураПараметров.Вставить("min_api_version", 1);
Возврат СтруктураПараметров;
КонецФункции
Функция ТокенВЗаголовки(Знач Токен)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
СтруктураЗаголовков = Новый Соответствие;
СтруктураЗаголовков.Вставить("X-Viber-Auth-Token", Токен);
Возврат СтруктураЗаголовков;
КонецФункции
#КонецОбласти

384
src/ru/OPI/src/CommonModules/OPI_YandexDisk/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/core/Modules/OPI_YandexDisk.os
// OneScript: ./OInt/core/Modules/OPI_YandexDisk.os
// Lib: Yandex Disk
// CLI: yadisk
@ -37,7 +37,7 @@
//@skip-check wrong-string-literal-content
// Раскомментировать, если выполняется OneScript
// #Использовать "../../tools"
// #Использовать "../../tools"
#Область ПрограммныйИнтерфейс
@ -45,217 +45,217 @@
// Получить информацию о диске
// Получает информацию о текущем диске
//
//
// Параметры:
// Токен - Строка - Токен - token
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьИнформациюОДиске(Знач Токен) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
Заголовки = ЗаголовокАвторизации(Токен);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk", , Заголовки);
Возврат Ответ;
КонецФункции
// Создать папку
// Создает каталог на диске
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к созаваемой папке - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция СоздатьПапку(Знач Токен, Знач Путь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
Заголовки = ЗаголовокАвторизации(Токен);
URL = "https://cloud-api.yandex.net/v1/disk/resources";
Href = "href";
Параметры = Новый Структура;
Параметры.Вставить("path", Путь);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Put(URL + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
URLОтвета = Ответ[Href];
Если Не ЗначениеЗаполнено(URLОтвета) Тогда
Возврат Ответ;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URLОтвета, , Заголовки);
Возврат Ответ;
КонецФункции
// Получить объект
// Получает информацию об объекте диска по заданному пути
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к папке или файлу - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьОбъект(Знач Токен, Знач Путь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Параметры.Вставить("path", Путь);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/resources", Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Удалить объект
// Удаляет объект по заданному пути
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к удаляемой папке или файлу - path
// ВКорзину - Булево - В корзину - can
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция УдалитьОбъект(Знач Токен, Знач Путь, Знач ВКорзину = Истина) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьБулево(ВКорзину);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Параметры.Вставить("path" , Путь);
Параметры.Вставить("permanently", Не ВКорзину);
Ответ = OPI_Инструменты.Delete("https://cloud-api.yandex.net/v1/disk/resources", Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Создать копию объекта
// Создает копию объекта по заданному пути и пути к оригиналу
//
//
// Параметры:
// Токен - Строка - Токен - token
// Оригинал - Строка - Путь к оригинальному файлу или каталогу - from
// Путь - Строка - Путь назначения для копии - to
// Перезаписывать - Булево - Перезаписывать если файл с таким именем уже существует - rewrite
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция СоздатьКопиюОбъекта(Знач Токен, Знач Оригинал, Знач Путь, Знач Перезаписывать = Ложь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Оригинал);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьБулево(Перезаписывать);
Заголовки = ЗаголовокАвторизации(Токен);
URL = "https://cloud-api.yandex.net/v1/disk/resources/copy";
Href = "href";
Параметры = Новый Структура;
Параметры.Вставить("from" , Оригинал);
Параметры.Вставить("path" , Путь);
Параметры.Вставить("overwrite" , Перезаписывать);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Post(URL + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
URLОтвета = Ответ[Href];
Если Не ЗначениеЗаполнено(URLОтвета) Тогда
Возврат Ответ;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URLОтвета, , Заголовки);
Возврат Ответ;
КонецФункции
// Получить ссылку для скачивания
// Получает ссылку для скачивания файла
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к файлу для скачивания - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьСсылкуДляСкачивания(Знач Токен, Знач Путь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Параметры.Вставить("path", Путь);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/resources/download", Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Скачать файл
// Скачивает файл по указанному пути
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к файлу для скачивания - path
// ПутьСохранения - Строка - Путь сохранения файла - out
//
// ПутьСохранения - Строка - Путь сохранения файла - out
//
// Возвращаемое значение:
// ДвоичныеДанные,Строка - Двоичные данные или путь к файлу при указании параметра ПутьСохранения
Функция СкачатьФайл(Знач Токен, Знач Путь, Знач ПутьСохранения = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ПутьСохранения);
Ответ = ПолучитьСсылкуДляСкачивания(Токен, Путь);
URL = Ответ["href"];
Если Не ЗначениеЗаполнено(URL) Тогда
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URL, , , ПутьСохранения);
Возврат Ответ;
КонецФункции
// Получить список файлов
// Получает список файлов с или без отбора по типу
// Список доступных типов: audio, backup, book, compressed, data, development,
// diskimage, document, encoded, executable, flash, font,
// Список доступных типов: audio, backup, book, compressed, data, development,
// diskimage, document, encoded, executable, flash, font,
// mage, settings, spreadsheet, text, unknown, video, web
//
//
// Параметры:
// Токен - Строка - Токен - token
// Количество - Число,Строка - Количество возвращаемых объектов - amount
// СмещениеОтНачала - Число - Смещение для получение объектов не из начала списка - offset
// ОтборПоТипу - Строка - Отбор по типу файла - type
// СортироватьПоДате - Булево - Истина > сортировать по дате, Ложь > по алфавиту - datesort
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьСписокФайлов(Знач Токен
@ -263,50 +263,50 @@
, Знач СмещениеОтНачала = 0
, Знач ОтборПоТипу = ""
, Знач СортироватьПоДате = Ложь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Количество);
OPI_ПреобразованиеТипов.ПолучитьСтроку(СмещениеОтНачала);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ОтборПоТипу);
OPI_ПреобразованиеТипов.ПолучитьБулево(СортироватьПоДате);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Количество) Тогда
Параметры.Вставить("limit", OPI_Инструменты.ЧислоВСтроку(Количество));
КонецЕсли;
Если ЗначениеЗаполнено(СмещениеОтНачала) Тогда
Параметры.Вставить("offset", OPI_Инструменты.ЧислоВСтроку(СмещениеОтНачала));
КонецЕсли;
Если ЗначениеЗаполнено(ОтборПоТипу) Тогда
Параметры.Вставить("media_type", ОтборПоТипу);
КонецЕсли;
Если СортироватьПоДате Тогда
Назначение = "last-uploaded";
Иначе
Назначение = "files";
КонецЕсли;
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/resources/" + Назначение, Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Переместить объект
// Перемещает объект по заданному пути и пути к оригиналу
//
//
// Параметры:
// Токен - Строка - Токен - token
// Оригинал - Строка - Путь к оригинальному файлу или папке - from
// Путь - Строка - Путь назначение для перемещения - to
// Перезаписывать - Булево - Перезаписывать если файл с таким именем уже существует - rewrite
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПереместитьОбъект(Знач Токен, Знач Оригинал, Знач Путь, Знач Перезаписывать = Ложь) Экспорт
@ -315,97 +315,97 @@
OPI_ПреобразованиеТипов.ПолучитьСтроку(Оригинал);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьБулево(Перезаписывать);
Заголовки = ЗаголовокАвторизации(Токен);
URL = "https://cloud-api.yandex.net/v1/disk/resources/move";
Href = "href";
Параметры = Новый Структура;
Параметры.Вставить("from" , Оригинал);
Параметры.Вставить("path" , Путь);
Параметры.Вставить("overwrite" , Перезаписывать);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Post(URL + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Post(URL + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
Если Не ЗначениеЗаполнено(URLОтвета) Тогда
Возврат Ответ;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URLОтвета, , Заголовки);
Возврат Ответ;
КонецФункции
// Загрузить файл
// Загружает файл на диск по заданному пути
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь для сохранение файла на Диске - path
// Файл - Строка,ДвоичныеДанные - Файл для загрузки - file
// Перезаписывать - Булево - Перезаписывать, если файл с таким именем уже существует - rewrite
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ЗагрузитьФайл(Знач Токен, Знач Путь, Знач Файл, Знач Перезаписывать = Ложь) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьБулево(Перезаписывать);
OPI_ПреобразованиеТипов.ПолучитьДвоичныеДанные(Файл);
Заголовки = ЗаголовокАвторизации(Токен);
Href = "href";
Href = "href";
Файл = Новый Структура("file", Файл);
Параметры = Новый Структура;
Параметры.Вставить("path" , Путь);
Параметры.Вставить("overwrite" , Перезаписывать);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/resources/upload", Параметры, Заголовки);
URL = Ответ[Href];
Если Не ЗначениеЗаполнено(URL) Тогда
Возврат Ответ;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.PutMultipart(URL, Новый Структура(), Файл, "multipart", Заголовки);
Возврат Ответ;
КонецФункции
// Загрузить файл по URL
// Загружает файл на диск, забирая его по заданному URL
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь помещения загруженного файла - path
// Адрес - Строка - URL файла - url
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ЗагрузитьФайлПоURL(Знач Токен, Знач Путь, Знач Адрес) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Адрес);
Заголовки = ЗаголовокАвторизации(Токен);
URL = "https://cloud-api.yandex.net/v1/disk/resources/upload";
Параметры = Новый Структура;
Параметры.Вставить("url" , КодироватьСтроку(Адрес, СпособКодированияСтроки.КодировкаURL));
Параметры.Вставить("path", Путь);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Post(URL + Параметры, , Заголовки, Ложь);
Возврат Ответ;
КонецФункции
#КонецОбласти
@ -414,186 +414,186 @@
// Опубликовать объект
// Публикует объект диска в публичный доступ
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к публикуемому объекту - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ОпубликоватьОбъект(Знач Токен, Знач Путь) Экспорт
Возврат ПереключениеОбщегоДоступа(Токен, Путь, Истина);
Возврат ПереключениеОбщегоДоступа(Токен, Путь, Истина);
КонецФункции
// Отменить публикацию объекта
// Отменяет публикацию ранее опубликованного объекта
//
//
// Параметры:
// Токен - Строка - Токен - token
// Путь - Строка - Путь к опубликованному ранее объекту - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ОтменитьПубликациюОбъекта(Знач Токен, Знач Путь) Экспорт
Возврат ПереключениеОбщегоДоступа(Токен, Путь, Ложь);
КонецФункции
// Получить список опубликованных объектов.
// Получает список опубликованных объектов
//
//
// Параметры:
// Токен - Строка - Токен - token
// Токен - Строка - Токен - token
// Количество - Число - Количество возвращаемых объектов - amount
// СмещениеОтНачала - Число - Смещение для получение объектов не из начала списка - offset
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьСписокОпубликованныхОбъектов(Знач Токен, Знач Количество = 0, Знач СмещениеОтНачала = 0) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Количество);
OPI_ПреобразованиеТипов.ПолучитьСтроку(СмещениеОтНачала);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Количество) Тогда
Параметры.Вставить("limit", Количество);
КонецЕсли;
Если ЗначениеЗаполнено(СмещениеОтНачала) Тогда
Параметры.Вставить("offset", СмещениеОтНачала);
КонецЕсли;
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/resources/public", Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить публичный объект
// Получает информацию об опубликованном объекте по его URL
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - Адрес объекта - url
// URL - Строка - Адрес объекта - url
// Количество - Число - Количество возвращаемых вложенных объектов (для каталога) - amount
// СмещениеОтНачала - Число - Смещение для получение вложенных объектов не из начала списка - offset
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьПубличныйОбъект(Знач Токен, Знач URL, Знач Количество = 0, Знач СмещениеОтНачала = 0) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(URL);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Количество);
OPI_ПреобразованиеТипов.ПолучитьСтроку(СмещениеОтНачала);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Количество) Тогда
Параметры.Вставить("limit", OPI_Инструменты.ЧислоВСтроку(Количество));
КонецЕсли;
Если ЗначениеЗаполнено(СмещениеОтНачала) Тогда
Параметры.Вставить("offset", OPI_Инструменты.ЧислоВСтроку(СмещениеОтНачала));
КонецЕсли;
Параметры.Вставить("public_key", URL);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/public/resources", Параметры, Заголовки);
Возврат Ответ;
КонецФункции
// Получить ссылку скачивания публичного объекта
// Получает прямую ссылку для скачивания публичного объекта
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - Адрес объекта - url
// Путь - Строка - Путь внутри объекта - path
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьСсылкуСкачиванияПубличногоОбъекта(Знач Токен, Знач URL, Знач Путь = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(URL);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
Заголовки = ЗаголовокАвторизации(Токен);
Параметры = Новый Структура;
Если ЗначениеЗаполнено(Путь) Тогда
Параметры.Вставить("path", Путь);
КонецЕсли;
Параметры.Вставить("public_key", URL);
Ответ = OPI_Инструменты.Get("https://cloud-api.yandex.net/v1/disk/public/resources/download", Параметры, Заголовки);
Возврат Ответ;
Возврат Ответ;
КонецФункции
// Сохранить публичный объект на диск
// Сохраняет публичный объект на ваш диск
//
//
// Параметры:
// Токен - Строка - Токен - token
// URL - Строка - Адрес объекта - url
// Откуда - Строка - Путь внутри публичного каталога (только для папок) - from
// Куда - Строка - Путь сохранения файла - to
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция СохранитьПубличныйОбъектНаДиск(Знач Токен, Знач URL, Откуда = "", Куда = "") Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(URL);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Откуда);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Куда);
Заголовки = ЗаголовокАвторизации(Токен);
Адрес = "https://cloud-api.yandex.net/v1/disk/public/resources/save-to-disk";
Href = "href";
Параметры = Новый Структура;
Параметры.Вставить("public_key", КодироватьСтроку(URL, СпособКодированияСтроки.КодировкаURL));
Если ЗначениеЗаполнено(Откуда) Тогда
Параметры.Вставить("path", Откуда);
КонецЕсли;
Если ЗначениеЗаполнено(Куда) Тогда
Параметры.Вставить("save_path", Куда);
КонецЕсли;
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Post(Адрес + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
URLОтвета = Ответ[Href];
Если Не ЗначениеЗаполнено(URLОтвета) Тогда
Возврат Ответ;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URLОтвета, , Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти
#КонецОбласти
@ -601,42 +601,42 @@
#Область СлужебныеПроцедурыИФункции
Функция ЗаголовокАвторизации(Знач Токен)
Заголовки = Новый Соответствие;
Заголовки.Вставить("Authorization", "OAuth " + Токен);
Возврат Заголовки;
КонецФункции
Функция ПереключениеОбщегоДоступа(Знач Токен, Знач Путь, Знач ОбщийДоступ)
Функция ПереключениеОбщегоДоступа(Знач Токен, Знач Путь, Знач ОбщийДоступ)
OPI_ПреобразованиеТипов.ПолучитьСтроку(Токен);
OPI_ПреобразованиеТипов.ПолучитьСтроку(Путь);
OPI_ПреобразованиеТипов.ПолучитьБулево(ОбщийДоступ);
Заголовки = ЗаголовокАвторизации(Токен);
Назначение = ?(ОбщийДоступ, "publish", "unpublish");
Href = "href";
URL = "https://cloud-api.yandex.net/v1/disk/resources/" + Назначение;
Параметры = Новый Структура;
Параметры.Вставить("path", Путь);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Параметры = OPI_Инструменты.ПараметрыЗапросаВСтроку(Параметры);
Ответ = OPI_Инструменты.Put(URL + Параметры, , Заголовки, Ложь);
URLОтвета = Ответ[Href];
Если Не ЗначениеЗаполнено(URLОтвета) Тогда
Возврат Ответ;
КонецЕсли;
Возврат Ответ;
КонецЕсли;
Ответ = OPI_Инструменты.Get(URLОтвета, , Заголовки);
Возврат Ответ;
КонецФункции
#КонецОбласти
#КонецОбласти

40
src/ru/OPI/src/CommonModules/OPI_YandexID/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/core/Modules/OPI_YandexID.os
// OneScript: ./OInt/core/Modules/OPI_YandexID.os
// Lib: Yandex ID
// CLI: yandex
@ -41,77 +41,77 @@
// Получить код подтверждения
// Получает код подтверждения и адрес страницы, на которой его необходимо ввести
//
//
// Параметры:
// ClientId - Строка - Client id - id
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПолучитьКодПодтверждения(Знач ClientId) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientId);
Параметры = Новый Структура("client_id", ClientId);
Ответ = OPI_Инструменты.Post("https://oauth.yandex.ru/device/code", Параметры, , Ложь);
Возврат Ответ;
КонецФункции
// Преобразовать код в токен
// Преобразовывает код в токен после ввода кода при выполнении ПолучитьКодПодтверждения
//
//
// Параметры:
// ClientId - Строка - Client id - id
// ClientSecret - Строка - Client secret - secret
// КодУстройства - Строка - device_code из ПолучитьКодПодтверждения() - device
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ПреобразоватьКодВТокен(Знач ClientId, Знач ClientSecret, Знач КодУстройства) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientId);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientSecret);
OPI_ПреобразованиеТипов.ПолучитьСтроку(КодУстройства);
Параметры = Новый Структура;
Параметры.Вставить("grant_type" , "device_code");
Параметры.Вставить("code" , КодУстройства);
Параметры.Вставить("client_id" , ClientId);
Параметры.Вставить("client_secret" , ClientSecret);
Ответ = OPI_Инструменты.Post("https://oauth.yandex.ru/token", Параметры, , Ложь);
Возврат Ответ;
КонецФункции
// Обновить токен
// Обновляет токен по Refresh token
//
//
// Параметры:
// ClientId - Строка - Client id - id
// ClientSecret - Строка - Client secret - secret
// RefreshToken - Строка - Refresh token - refresh
//
//
// Возвращаемое значение:
// Соответствие Из КлючИЗначение - сериализованный JSON ответа от Yandex
Функция ОбновитьТокен(Знач ClientId, Знач ClientSecret, Знач RefreshToken) Экспорт
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientId);
OPI_ПреобразованиеТипов.ПолучитьСтроку(ClientSecret);
OPI_ПреобразованиеТипов.ПолучитьСтроку(RefreshToken);
Параметры = Новый Структура;
Параметры.Вставить("grant_type" , "refresh_token");
Параметры.Вставить("refresh_token" , RefreshToken);
Параметры.Вставить("client_id" , ClientId);
Параметры.Вставить("client_secret" , ClientSecret);
Ответ = OPI_Инструменты.Post("https://oauth.yandex.ru/token", Параметры, , Ложь);
Возврат Ответ;
КонецФункции
#КонецОбласти

654
src/ru/OPI/src/CommonModules/OPI_Инструменты/Module.bsl
View File

File diff suppressed because it is too large Load Diff

48
src/ru/OPI/src/CommonModules/OPI_Криптография/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/tools/Modules/internal/Modules/OPI_Криптография.os
// OneScript: ./OInt/tools/Modules/internal/Modules/OPI_Криптография.os
// MIT License
@ -39,75 +39,75 @@
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2019, ООО 1С-Софт
// Все права защищены. Эта программа и сопроводительные материалы предоставляются
// Все права защищены. Эта программа и сопроводительные материалы предоставляются
// в соответствии с условиями лицензии Attribution 4.0 International (CC BY 4.0)
// Текст лицензии доступен по ссылке:
// https://creativecommons.org/licenses/by/4.0/legalcode
///////////////////////////////////////////////////////////////////////////////////////////////////////
Функция HMACSHA256(Знач Ключ, Знач Данные) Экспорт
Возврат HMAC(Ключ, Данные, ХешФункция.SHA256, 64);
КонецФункции
Функция Хеш(ДвоичныеДанные, Тип) Экспорт
Хеширование = Новый ХешированиеДанных(Тип);
Хеширование.Добавить(ДвоичныеДанные);
Возврат Хеширование.ХешСумма;
КонецФункции
Функция HMAC(Знач Ключ, Знач Данные, Тип, РазмерБлока) Экспорт
Дважды = 2;
Если Ключ.Размер() > РазмерБлока Тогда
Ключ = Хеш(Ключ, Тип);
КонецЕсли;
Если Ключ.Размер() <= РазмерБлока Тогда
Ключ = ПолучитьHexСтрокуИзДвоичныхДанных(Ключ);
Ключ = Лев(Ключ + ПовторитьСтроку("00", РазмерБлока), РазмерБлока * Дважды);
Ключ = ПолучитьHexСтрокуИзДвоичныхДанных(Ключ);
Ключ = Лев(Ключ + ПовторитьСтроку("00", РазмерБлока), РазмерБлока * Дважды);
КонецЕсли;
Ключ = ПолучитьБуферДвоичныхДанныхИзДвоичныхДанных(ПолучитьДвоичныеДанныеИзHexСтроки(Ключ));
Ipad = ПолучитьБуферДвоичныхДанныхИзHexСтроки(ПовторитьСтроку("36", РазмерБлока));
Opad = ПолучитьБуферДвоичныхДанныхИзHexСтроки(ПовторитьСтроку("5c", РазмерБлока));
Ipad.ЗаписатьПобитовоеИсключительноеИли(0, Ключ);
Ikeypad = ПолучитьДвоичныеДанныеИзБуфераДвоичныхДанных(ipad);
Opad.ЗаписатьПобитовоеИсключительноеИли(0, Ключ);
Okeypad = ПолучитьДвоичныеДанныеИзБуфераДвоичныхДанных(opad);
Возврат Хеш(СклеитьДвоичныеДанные(okeypad, Хеш(СклеитьДвоичныеДанные(ikeypad, Данные), Тип)), Тип);
КонецФункции
Функция СклеитьДвоичныеДанные(ДвоичныеДанные1, ДвоичныеДанные2) Экспорт
МассивДвоичныхДанных = Новый Массив;
МассивДвоичныхДанных.Добавить(ДвоичныеДанные1);
МассивДвоичныхДанных.Добавить(ДвоичныеДанные2);
Возврат СоединитьДвоичныеДанные(МассивДвоичныхДанных);
КонецФункции
Функция ПовторитьСтроку(Строка, Количество) Экспорт
Части = Новый Массив(Количество);
Для К = 1 По Количество Цикл
Части.Добавить(Строка);
КонецЦикла;
Возврат СтрСоединить(Части, "");
КонецФункции
#КонецОбласти

218
src/ru/OPI/src/CommonModules/OPI_ПолучениеДанныхТестов/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/tools/Modules/OPI_ПолучениеДанныхТестов.os
// OneScript: ./OInt/tools/Modules/OPI_ПолучениеДанныхТестов.os
// MIT License
@ -46,10 +46,10 @@
#Область СлужебныйПрограммныйИнтерфейс
Функция ПолучитьСоответствиеРазделовТестирования() Экспорт
СтандартныеЗависимости = "[Decode, Build]";
ЗависимостиГугл = "Testing-GoogleWorkspace";
Разделы = Новый Структура;
Разделы.Вставить("Telegram" , СтандартныеЗависимости);
Разделы.Вставить("VK" , СтандартныеЗависимости);
@ -57,7 +57,7 @@
Разделы.Вставить("Twitter" , СтандартныеЗависимости);
Разделы.Вставить("YandexDisk" , СтандартныеЗависимости);
Разделы.Вставить("GoogleWorkspace", СтандартныеЗависимости);
Разделы.Вставить("GoogleCalendar" , ЗависимостиГугл);
Разделы.Вставить("GoogleCalendar" , ЗависимостиГугл);
Разделы.Вставить("GoogleDrive" , ЗависимостиГугл);
Разделы.Вставить("GoogleSheets" , ЗависимостиГугл);
Разделы.Вставить("Notion" , СтандартныеЗависимости);
@ -65,13 +65,13 @@
Разделы.Вставить("Airtable" , СтандартныеЗависимости);
Разделы.Вставить("Dropbox" , СтандартныеЗависимости);
Разделы.Вставить("Bitrix24" , СтандартныеЗависимости);
Возврат Разделы;
КонецФункции
Функция ПолучитьТаблицуТестов() Экспорт
Телеграм = "Telegram";
ВКонтакте = "VK";
ЯДиск = "YandexDisk";
@ -86,13 +86,13 @@
АирТ = "Airtable";
ДропБокс = "Dropbox";
Битрикс = "Bitrix24";
ТаблицаТестов = Новый ТаблицаЗначений;
ТаблицаТестов.Колонки.Добавить("Метод");
ТаблицаТестов.Колонки.Добавить("Синоним");
ТаблицаТестов.Колонки.Добавить("Раздел");
НовыйТест(ТаблицаТестов, "Телеграм_ПолучитьИнформациюБота" , "Получить информацию бота" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_ПолучитьИнформациюБота" , "Получить информацию бота" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_ПолучитьОбновления" , "Получить обновления" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_УстановитьWebhook" , "Установить Webhook" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_ОтправитьТекстовоеСообщение" , "Отправить текстовое сообщение" , Телеграм);
@ -114,7 +114,7 @@
НовыйТест(ТаблицаТестов, "Телеграм_СоздатьУдалитьТемуФорума" , "Создать/Удалить тему форума" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_ИзменитьИмяГлавнойТемы" , "Изменить имя главной темы" , Телеграм);
НовыйТест(ТаблицаТестов, "Телеграм_СкрытьПоказатьГлавнуюТему" , "Скрыть/Показать главную тему" , Телеграм);
НовыйТест(ТаблицаТестов, "ВК_СоздатьСсылкуТокена" , "Создать ссылку получения токена", ВКонтакте);
НовыйТест(ТаблицаТестов, "ВК_СоздатьУдалитьПост" , "Создать/Удалить пост" , ВКонтакте);
НовыйТест(ТаблицаТестов, "ВК_СоздатьСоставнойПост" , "Создать/Удалить составной пост" , ВКонтакте);
@ -135,7 +135,7 @@
НовыйТест(ТаблицаТестов, "ВК_ПолучитьСписокСвойств" , "Получить список свойств" , ВКонтакте);
НовыйТест(ТаблицаТестов, "ВК_ПолучитьСписокЗаказов" , "Получить список заказов" , ВКонтакте);
НовыйТест(ТаблицаТестов, "ВК_ЗагрузитьВидео" , "Загрузить видео" , ВКонтакте);
НовыйТест(ТаблицаТестов, "ЯДиск_ПолучитьИнформациюОДиске" , "Получить информацию о диске" , ЯДиск);
НовыйТест(ТаблицаТестов, "ЯДиск_СоздатьПапку" , "Создать папку" , ЯДиск);
НовыйТест(ТаблицаТестов, "ЯДиск_ЗагрузитьПоАдресуПолучитьОбъект", "Загрузить по URL и получить" , ЯДиск);
@ -146,25 +146,25 @@
НовыйТест(ТаблицаТестов, "ЯДиск_ПереместитьОбъект" , "Переместить объект" , ЯДиск);
НовыйТест(ТаблицаТестов, "ЯДиск_ДействияПубличныхОбъектов" , "Действия с публичными объектами", ЯДиск);
НовыйТест(ТаблицаТестов, "ЯДиск_ПолучитьСписокОпубликованных" , "Получить список опубликованных" , ЯДиск);
НовыйТест(ТаблицаТестов, "ГВ_ПолучитьСсылкуАвторизации" , "Получить ссылку авторизации" , ВСпейс);
НовыйТест(ТаблицаТестов, "ГВ_ПолучитьТокен" , "Получить токен" , ВСпейс);
НовыйТест(ТаблицаТестов, "ГВ_ОбновитьТокен" , "Обновить токен" , ВСпейс);
НовыйТест(ТаблицаТестов, "ГК_ПолучитьСписокКалендарей" , "Получить список календарей" , Календарь);
НовыйТест(ТаблицаТестов, "ГК_СоздатьУдалитьКалендарь" , "Создать/Удалить календарь" , Календарь);
НовыйТест(ТаблицаТестов, "ГК_СоздатьУдалитьСобытие" , "Создать/Удалить событие" , Календарь);
НовыйТест(ТаблицаТестов, "ГК_ПолучитьСписокСобытий" , "Получить список событий" , Календарь);
НовыйТест(ТаблицаТестов, "ГД_ПолучитьСписокКаталогов" , "Получить список каталогов" , Драйв);
НовыйТест(ТаблицаТестов, "ГД_ЗагрузитьУдалитьФайл" , "Загрузить/Удалить Файл" , Драйв);
НовыйТест(ТаблицаТестов, "ГД_СоздатьУдалитьКомментарий" , "Создать/Удалить кооментарий" , Драйв);
НовыйТест(ТаблицаТестов, "ГД_СоздатьКаталог" , "Создать/Удалить каталог" , Драйв);
НовыйТест(ТаблицаТестов, "ГТ_СоздатьТаблицу" , "Создать таблицу" , Таблицы);
НовыйТест(ТаблицаТестов, "ГТ_ПолучитьТаблицу" , "Получить таблицу" , Таблицы);
НовыйТест(ТаблицаТестов, "ГТ_ЗаполнитьОчиститьЯчейки" , "Заполнить/Очистить ячейки" , Таблицы);
НовыйТест(ТаблицаТестов, "Твиттер_ПолучитьСсылкуАвторизации" , "Получить ссылку авторизации" , Твиттер);
НовыйТест(ТаблицаТестов, "Твиттер_ОбновитьТокен" , "Обновить токен" , Твиттер);
НовыйТест(ТаблицаТестов, "Твиттер_СоздатьТекстовыйТвит" , "Текстовый твит" , Твиттер);
@ -172,7 +172,7 @@
НовыйТест(ТаблицаТестов, "Твиттер_СоздатьТвитСВидео" , "Твит с видео" , Твиттер);
НовыйТест(ТаблицаТестов, "Твиттер_СоздатьТвитСГиф" , "Твит с гиф" , Твиттер);
НовыйТест(ТаблицаТестов, "Твиттер_СоздатьТвитСОпросом" , "Твит с опросом" , Твиттер);
НовыйТест(ТаблицаТестов, "Вайбер_ПолучитьИнформациюОКанале" , "Получить информацию канала" , Вайбер);
НовыйТест(ТаблицаТестов, "Вайбер_ПолучитьДанныеПользователя" , "Получить данные пользователя" , Вайбер);
НовыйТест(ТаблицаТестов, "Вайбер_ПолучитьОнлайнПользователей" , "Получить онлайн пользователей" , Вайбер);
@ -182,7 +182,7 @@
НовыйТест(ТаблицаТестов, "Вайбер_ОтправитьКонтакт" , "Отправить контакт" , Вайбер);
НовыйТест(ТаблицаТестов, "Вайбер_ОтправитьЛокацию" , "Отправить локацию" , Вайбер);
НовыйТест(ТаблицаТестов, "Вайбер_ОтправитьСсылку" , "Отправить ссылку" , Вайбер);
НовыйТест(ТаблицаТестов, "Ноушн_СоздатьСтраницу" , "Создать страницу" , Ноушн);
НовыйТест(ТаблицаТестов, "Ноушн_СоздатьИзменитьБазу" , "Создать/Изменить базу" , Ноушн);
НовыйТест(ТаблицаТестов, "Ноушн_ПолучитьИнформациюОСтранице" , "Получить информацию о странице" , Ноушн);
@ -192,7 +192,7 @@
НовыйТест(ТаблицаТестов, "Ноушн_СоздатьУдалитьБлок" , "Создать/Удалить блок" , Ноушн);
НовыйТест(ТаблицаТестов, "Ноушн_ПолучитьПользователей" , "Получить пользователей" , Ноушн);
НовыйТест(ТаблицаТестов, "Ноушн_ПолучитьДанныеПользователя" , "Получить данные пользователя" , Ноушн);
НовыйТест(ТаблицаТестов, "Слак_ПолучитьИнформациюОБоте" , "Получить информацию о боте" , Слак);
НовыйТест(ТаблицаТестов, "Слак_ПолучитьСписокПользователей" , "Получить список пользователей" , Слак);
НовыйТест(ТаблицаТестов, "Слак_ПолучитьСписокОбластей" , "Получить список областей" , Слак);
@ -206,12 +206,12 @@
НовыйТест(ТаблицаТестов, "Слак_ЗагрузитьУдалитьФайл" , "Загрузить/Удалить файл" , Слак);
НовыйТест(ТаблицаТестов, "Слак_ПолучитьСписокВФ" , "Получить список внеш. файлов" , Слак);
НовыйТест(ТаблицаТестов, "Слак_ЗагрузитьУдалитьВФ" , "Загрузить/Удалить внеш. файл" , Слак);
НовыйТест(ТаблицаТестов, "АТ_СоздатьБазу" , "Создать/Изменить базу" , АирТ);
НовыйТест(ТаблицаТестов, "АТ_СоздатьТаблицу" , "Создать/Изменить таблицу" , АирТ);
НовыйТест(ТаблицаТестов, "АТ_СоздатьПоле" , "Создать/Изменить поле" , АирТ);
НовыйТест(ТаблицаТестов, "АТ_СоздатьУдалитьЗаписи" , "Создать/Удалить записи" , АирТ);
НовыйТест(ТаблицаТестов, "ДропБокс_ПолучитьОбновитьТокен" , "Получить/Обновить токен" , ДропБокс);
НовыйТест(ТаблицаТестов, "ДропБокс_ЗагрузитьФайл" , "Загрузить файл" , ДропБокс);
НовыйТест(ТаблицаТестов, "ДропБокс_ЗагрузитьФайлПоURL" , "Загрузить файл по URL" , ДропБокс);
@ -220,7 +220,7 @@
НовыйТест(ТаблицаТестов, "ДропБокс_ПолучитьАккаунт" , "Получить данные аккаунта" , ДропБокс);
НовыйТест(ТаблицаТестов, "ДропБокс_РаботаСДоступами" , "Работа с доступами" , ДропБокс);
НовыйТест(ТаблицаТестов, "ДропБокс_ПолучитьСписокФайловПапки" , "Получить список файлов папки" , ДропБокс);
НовыйТест(ТаблицаТестов, "Б24_РаботаСТокеном" , "Работа с токеном" , Битрикс);
НовыйТест(ТаблицаТестов, "Б24_СерверноеВремя" , "Серверное время" , Битрикс);
НовыйТест(ТаблицаТестов, "Б24_РаботаСНовостями" , "Работа с новостями" , Битрикс);
@ -231,215 +231,215 @@
НовыйТест(ТаблицаТестов, "Б24_УчетРабочегоВремени" , "Учет рабочего времени" , Битрикс);
НовыйТест(ТаблицаТестов, "Б24_РаботаСЧатами" , "Работа с чатами" , Битрикс);
НовыйТест(ТаблицаТестов, "Б24_РаботаСУведомлениями" , "Работа с уведомлениями" , Битрикс);
Возврат ТаблицаТестов;
КонецФункции
КонецФункции
Функция ОжидаетЧто(Значение) Экспорт
Попытка
Модуль = ПолучитьОбщийМодуль("ЮТест");
Ожидаем = ТипЗнч(Модуль) = Тип("ОбщийМодуль");
Возврат Модуль.ОжидаетЧто(Значение);
Возврат Модуль.ОжидаетЧто(Значение);
Исключение
Возврат Ожидаем.Что(Значение);
КонецПопытки;
КонецФункции
Функция СформироватьТестыЯкс() Экспорт
Модуль = ПолучитьОбщийМодуль("ЮТТесты");
Разделы = ПолучитьСоответствиеРазделовТестирования();
ТаблицаТестов = ПолучитьТаблицуТестов();
Для Каждого Раздел Из Разделы Цикл
ТекущийРаздел = Раздел.Ключ;
Отбор = Новый Структура("Раздел", ТекущийРаздел);
ТестыРаздела = ТаблицаТестов.НайтиСтроки(Отбор);
Набор = Модуль.ДобавитьТестовыйНабор(ТекущийРаздел);
Для Каждого Тест Из ТестыРаздела Цикл
Набор.ДобавитьСерверныйТест(Тест.Метод, Тест.Синоним);
КонецЦикла;
КонецЦикла;
Возврат "";
КонецФункции
Функция СформироватьТестыАссертс() Экспорт
ТаблицаТестов = ПолучитьТаблицуТестов();
МассивТестов = Новый Массив;
Для Каждого Тест Из ТаблицаТестов Цикл
Для Каждого Тест Из ТаблицаТестов Цикл
МассивТестов.Добавить(Тест.Метод);
КонецЦикла;
Возврат МассивТестов;
КонецФункции
Функция ПолучитьПараметр(Параметр) Экспорт
Функция ПолучитьПараметр(Параметр) Экспорт
Путь = ПутьКФайлуДанных();
Путь = ПутьКФайлуДанных();
Возврат ПолучитьЗначениеИзФайла(Параметр, Путь);
КонецФункции
Функция ПолучитьДвоичные(Параметр) Экспорт
Путь = ПутьКФайлуДанных();
Путь = ПутьКФайлуДанных();
ПараметрЛокальный = Параметр + "Local";
ЗначениеОсновной = ПолучитьЗначениеИзФайла(Параметр , Путь);
ЗначениеЛокальный = ПолучитьЗначениеИзФайла(ПараметрЛокальный, Путь);
ФайлЛокальный = Новый Файл(ЗначениеЛокальный);
Если ФайлЛокальный.Существует() Тогда
Значение = Новый ДвоичныеДанные(ЗначениеЛокальный);
Иначе
Значение = ЗначениеОсновной;
КонецЕсли;
Если ТипЗнч(Значение) = Тип("Строка") Тогда
Значение = ПолучитьФайлПути(Значение, ПараметрЛокальный);
Значение = ПолучитьФайлПути(Значение, ПараметрЛокальный);
КонецЕсли;
Возврат Значение;
КонецФункции
Функция ПолучитьФайлПути(Знач Путь, ПараметрЛокальный, Знач СохранятьЛокально = Истина) Экспорт
Если СтрНайти(Путь, "http") > 0
Если СтрНайти(Путь, "http") > 0
Или СтрНайти(Путь, "www") > 0 Тогда
ИВФ = ПолучитьИмяВременногоФайла();
ИВФ = ПолучитьИмяВременногоФайла();
КопироватьФайл(Путь, ИВФ);
Путь = ИВФ;
Путь = ИВФ;
Двоичные = Новый ДвоичныеДанные(Путь);
Если СохранятьЛокально Тогда
ЗаписатьПараметр(ПараметрЛокальный, ИВФ);
Иначе
УдалитьФайлы(ИВФ);
КонецЕсли;
Иначе
Двоичные = Новый ДвоичныеДанные(Путь);
КонецЕсли;
Возврат Двоичные;
КонецФункции
Процедура ПараметрВКоллекцию(Параметр, Коллекция) Экспорт
Значение = ПолучитьПараметр(Параметр);
Коллекция.Вставить(Параметр, Значение);
КонецПроцедуры
Процедура ДвоичныеВКоллекцию(Параметр, Коллекция) Экспорт
Значение = ПолучитьДвоичные(Параметр);
Коллекция.Вставить(Параметр, Значение);
КонецПроцедуры
Процедура ЗаписатьПараметр(Параметр, Значение) Экспорт
Путь = ПутьКФайлуДанных();
Путь = ПутьКФайлуДанных();
ЗаписатьПараметрВФайл(Параметр, Значение, Путь);
КонецПроцедуры
Процедура ЗаписатьЛог(Знач Результат, Знач Метод, Знач Библиотека = "") Экспорт
Шапка = Строка(OPI_Инструменты.ПолучитьТекущуюДату()) + " | " + Метод;
Попытка
Данные = OPI_Инструменты.JSONСтрокой(Результат);
Исключение
Данные = "Не JSON: " + Строка(Результат);
КонецПопытки;
Данные = " " + Данные;
Данные = " " + Данные;
Сообщить(Шапка);
Сообщить(Символы.ПС);
Сообщить(Данные);
Сообщить(Символы.ПС);
Сообщить("---------------------------------");
Сообщить(Символы.ПС);
Если ЗначениеЗаполнено(Библиотека) Тогда
ЗаписатьФайлЛога(Данные, Метод, Библиотека);
КонецЕсли;
КонецПроцедуры
#КонецОбласти
#Область СлужебныеПроцедурыИФункции
Функция ПолучитьЗначениеИзФайла(Параметр, Путь)
Значения = OPI_Инструменты.ПрочитатьJSONФайл(Путь);
Функция ПолучитьЗначениеИзФайла(Параметр, Путь)
Значения = OPI_Инструменты.ПрочитатьJSONФайл(Путь);
Возврат ?(Значения.Свойство(Параметр), Значения[Параметр], "");
КонецФункции
Функция ПутьКФайлуДанных()
Путь = "";
Путь = "";
ВозможныеПути = Новый Массив;
ВозможныеПути.Добавить("./data.json");
ВозможныеПути.Добавить("C:\GDrive\Мой диск\data.json");
ВозможныеПути.Добавить("D:\GD\Мой диск\data.json");
Для Каждого ВозможныйПуть Из ВозможныеПути Цикл
ФайлРепозитория = Новый Файл(ВозможныйПуть);
Если ФайлРепозитория.Существует() Тогда
Путь = ВозможныйПуть;
КонецЕсли;
КонецЕсли;
КонецЦикла;
Возврат Путь;
КонецФункции
Функция ПолучитьОбщийМодуль(Знач Имя)
УстановитьБезопасныйРежим(Истина);
Модуль = Вычислить(Имя);
УстановитьБезопасныйРежим(Ложь);
Возврат Модуль;
УстановитьБезопасныйРежим(Истина);
Модуль = Вычислить(Имя);
УстановитьБезопасныйРежим(Ложь);
Возврат Модуль;
КонецФункции
Процедура НовыйТест(ТаблицаЗначений, Знач Метод, Знач Синоним, Знач Раздел)
НовыйТест = ТаблицаЗначений.Добавить();
НовыйТест = ТаблицаЗначений.Добавить();
НовыйТест.Метод = Метод;
НовыйТест.Синоним = Синоним;
НовыйТест.Раздел = Раздел;
КонецПроцедуры
Процедура ЗаписатьПараметрВФайл(Знач Параметр, Знач Значение, Знач Путь)
Значения = OPI_Инструменты.ПрочитатьJSONФайл(Путь);
Значения.Вставить(Параметр, Значение);
@ -452,37 +452,37 @@
КонецПроцедуры
Процедура ЗаписатьФайлЛога(Знач Данные, Знач Метод, Знач Библиотека)
Попытка
ПутьЛогов = "./docs/ru/results";
ПутьЛоговБиблиотеки = ПутьЛогов + "/" + Библиотека;
КаталогЛогов = Новый Файл(ПутьЛогов);
Если Не КаталогЛогов.Существует() Тогда
СоздатьКаталог(ПутьЛогов);
КонецЕсли;
КаталогЛоговБиблиотеки = Новый Файл(ПутьЛоговБиблиотеки);
Если Не КаталогЛоговБиблиотеки.Существует() Тогда
СоздатьКаталог(ПутьЛоговБиблиотеки);
КонецЕсли;
ПутьКФайлу = ПутьЛоговБиблиотеки + "/" + Метод + ".log";
ФайлЛога = Новый Файл(ПутьКФайлу);
Если Не ФайлЛога.Существует() Тогда
ДокументЛога = Новый ТекстовыйДокумент;
ДокументЛога.УстановитьТекст(Данные);
ДокументЛога.Записать(ПутьКФайлу);
КонецЕсли;
Исключение
Сообщить("Не удалось записать файл лога!: " + ОписаниеОшибки());
Сообщить("Не удалось записать файл лога!: " + ОписаниеОшибки());
КонецПопытки;
КонецПроцедуры
#КонецОбласти

236
src/ru/OPI/src/CommonModules/OPI_ПреобразованиеТипов/Module.bsl
View File

@ -1,4 +1,4 @@
// OneScript: ./OInt/tools/Modules/OPI_ПреобразованиеТипов.os
// OneScript: ./OInt/tools/Modules/OPI_ПреобразованиеТипов.os
// MIT License
@ -39,268 +39,268 @@
#Область СлужебныйПрограммныйИнтерфейс
Процедура ПолучитьДвоичныеДанные(Значение) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Попытка
Попытка
Если ТипЗнч(Значение) = Тип("ДвоичныеДанные") Тогда
Возврат;
Иначе
Файл = Новый Файл(Значение);
Если Файл.Существует() Тогда
Значение = Новый ДвоичныеДанные(Значение);
ИначеЕсли СтрНайти(Значение, "//") Тогда
Значение = OPI_Инструменты.Get(Значение);
Иначе
Значение = Base64Значение(Значение);
КонецЕсли;
КонецЕсли;
Исключение
ВызватьИсключение "Ошибка получения двоичных данных из параметра: " + ОписаниеОшибки();
КонецПопытки;
КонецПроцедуры
Процедура ПолучитьДвоичныеИлиПоток(Значение) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Если ТипЗнч(Значение) <> Тип("Строка") Тогда
ПолучитьДвоичныеДанные(Значение);
Возврат;
КонецЕсли;
Файл = Новый Файл(Значение);
Если Файл.Существует() Тогда
Значение = Новый ФайловыйПоток(Значение, РежимОткрытияФайла.Открыть);
Значение = Новый ФайловыйПоток(Значение, РежимОткрытияФайла.Открыть);
Иначе
ПолучитьДвоичныеДанные(Значение);
КонецЕсли;
КонецПроцедуры
Процедура ПолучитьКоллекцию(Значение) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Попытка
Попытка
ИсходноеЗначение = Значение;
Если ЭтоКоллекция(Значение) Тогда
Возврат;
Иначе
Если ТипЗнч(Значение) = Тип("ДвоичныеДанные") Тогда
Значение = ПолучитьСтрокуИзДвоичныхДанных(Значение);
Значение = ПолучитьСтрокуИзДвоичныхДанных(Значение);
Иначе
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
КонецЕсли;
Файл = Новый Файл(Значение);
ЧтениеJSON = Новый ЧтениеJSON;
Если Файл.Существует() Тогда
ЧтениеJSON.ОткрытьФайл(Значение);
ИначеЕсли СтрНачинаетсяС(нРег(Значение), "http") Тогда
ИВФ = ПолучитьИмяВременногоФайла();
КопироватьФайл(Значение, ИВФ);
ЧтениеJSON.ОткрытьФайл(ИВФ);
ЧтениеJSON.Прочитать();
УдалитьФайлы(ИВФ);
Иначе
ЧтениеJSON.УстановитьСтроку(СокрЛП(Значение));
КонецЕсли;
Значение = ПрочитатьJSON(ЧтениеJSON, Истина, Неопределено, ФорматДатыJSON.ISO);
ЧтениеJSON.Закрыть();
Если (Не ЭтоКоллекция(Значение)) Или Не ЗначениеЗаполнено(Значение) Тогда
Значение = ИсходноеЗначение;
ПолучитьМассив(Значение);
КонецЕсли;
КонецЕсли;
Исключение
Значение = ИсходноеЗначение;
ПолучитьМассив(Значение);
ПолучитьМассив(Значение);
КонецПопытки;
КонецПроцедуры
Процедура ПолучитьМассив(Значение) Экспорт
Если ТипЗнч(Значение) = Тип("Массив") Тогда
Возврат;
КонецЕсли;
Если ТипЗнч(Значение) = Тип("Строка")
Если ТипЗнч(Значение) = Тип("Строка")
И СтрНачинаетсяС(Значение, "[")
И СтрЗаканчиваетсяНа(Значение, "]") Тогда
ЗапятаяВКавычках = "','";
Значение = СтрЗаменить(Значение, "['" , "");
Значение = СтрЗаменить(Значение, "']" , "");
Значение = СтрЗаменить(Значение, "', '" , ЗапятаяВКавычках);
Значение = СтрЗаменить(Значение, "' , '", ЗапятаяВКавычках);
Значение = СтрЗаменить(Значение, "' ,'" , ЗапятаяВКавычках);
Значение = СтрРазделить(Значение, ЗапятаяВКавычках, Ложь);
Для Н = 0 По Значение.ВГраница() Цикл
Для Н = 0 По Значение.ВГраница() Цикл
Значение[Н] = СокрЛП(Значение[Н]);
КонецЦикла;
Иначе
Если ТипЗнч(Значение) = Тип("Число") Тогда
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
КонецЕсли;
OPI_Инструменты.ЗначениеВМассив(Значение);
КонецЕсли;
КонецПроцедуры
Процедура ПолучитьБулево(Значение) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Попытка
Попытка
Если ТипЗнч(Значение) = Тип("Булево") Тогда
Возврат;
Иначе
Значение = Булево(Значение);
Значение = Булево(Значение);
КонецЕсли;
Исключение
ВызватьИсключение "Ошибка получения данных булево из параметра";
КонецПопытки;
КонецПроцедуры
Процедура ПолучитьСтроку(Значение, Знач ИзИсточника = Ложь) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Попытка
Попытка
Если ЭтоСимвольное(Значение) Тогда
Если Не ИзИсточника Тогда
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
Возврат;
Возврат;
КонецЕсли;
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
Значение = OPI_Инструменты.ЧислоВСтроку(Значение);
Файл = Новый Файл(Значение);
Если Файл.Существует() Тогда
ЧтениеТекста = Новый ЧтениеТекста(Значение);
Значение = ЧтениеТекста.Прочитать();
ЧтениеТекста.Закрыть();
ИначеЕсли СтрНачинаетсяС(нРег(Значение), "http") Тогда
ИВФ = ПолучитьИмяВременногоФайла();
КопироватьФайл(Значение, ИВФ);
ЧтениеТекста = Новый ЧтениеТекста(ИВФ);
Значение = ЧтениеТекста.Прочитать();
ЧтениеТекста.Закрыть();
УдалитьФайлы(ИВФ);
Иначе
Возврат;
КонецЕсли;
ИначеЕсли ТипЗнч(Значение) = Тип("ДвоичныеДанные") Тогда
Значение = ПолучитьСтрокуИзДвоичныхДанных(Значение);
ИначеЕсли ЭтоКоллекция(Значение) Тогда
Значение = OPI_Инструменты.JSONСтрокой(Значение);
Значение = OPI_Инструменты.JSONСтрокой(Значение);
Иначе
Возврат;
КонецЕсли;
Исключение
Значение = Строка(Значение);
Возврат;
КонецПопытки;
КонецПроцедуры
Процедура ПолучитьДату(Значение) Экспорт
Если Значение = Неопределено Тогда
Возврат;
КонецЕсли;
Дата = "Дата";
Попытка
Попытка
Если ТипЗнч(Значение) = Тип(Дата) Тогда
Возврат;
Иначе
Значение = XMLЗначение(Тип(Дата), Значение);
Иначе
Значение = XMLЗначение(Тип(Дата), Значение);
КонецЕсли;
Исключение
ООД = Новый ОписаниеТипов(Дата);
ООД = Новый ОписаниеТипов(Дата);
Значение = ООД.ПривестиЗначение(Значение);
КонецПопытки;
КонецПроцедуры
Процедура ПолучитьЧисло(Значение) Экспорт
ОписаниеТипа = Новый ОписаниеТипов("Число");
Значение = ОписаниеТипа.ПривестиЗначение(Значение);
Значение = ОписаниеТипа.ПривестиЗначение(Значение);
КонецПроцедуры
#КонецОбласти
@ -308,19 +308,19 @@
#Область СлужебныеПроцедурыИФункции
Функция ЭтоКоллекция(Знач Значение)
Возврат ТипЗнч(Значение) = Тип("Массив")
Возврат ТипЗнч(Значение) = Тип("Массив")
Или ТипЗнч(Значение) = Тип("Структура")
Или ТипЗнч(Значение) = Тип("Соответствие");
КонецФункции
КонецФункции
Функция ЭтоСимвольное(Знач Значение)
Возврат ТипЗнч(Значение) = Тип("Строка")
Или ТипЗнч(Значение) = Тип("Число")
Или ТипЗнч(Значение) = Тип("Дата");
КонецФункции
#КонецОбласти
Возврат ТипЗнч(Значение) = Тип("Строка")
Или ТипЗнч(Значение) = Тип("Число")
Или ТипЗнч(Значение) = Тип("Дата");
КонецФункции
#КонецОбласти

6862
src/ru/OPI/src/CommonModules/OPI_Тесты/Module.bsl
View File

File diff suppressed because it is too large Load Diff