Get best of the week

Operasi CRUD dengan Entitas di DialogFlow (C #)

pengantar


Baru-baru ini, saya mulai mengerjakan proyek baru, yang termasuk bekerja dengan layanan Google (AI) yang sudah terkenal - DialogFlow. Intinya adalah bahwa kami memiliki bot (Telegram) yang bekerja dengan API dari beberapa situs, sementara DialogFlow sendiri membantu kami untuk menyusun komunikasi dengan seseorang, yang pada dasarnya ia dibuat. Saya harus mengatakan bahwa artikel ini ditujukan untuk orang-orang yang baru saja mulai berkenalan dengan layanan atau sudah memiliki sedikit pengalaman, sehingga syarat-syarat berikut ini mungkin: Maksud, Konteks, Tindakan, Peristiwa dan untuk apa yang kami kumpulkan demi - Entitas. Saya harap artikel ini akan bermanfaat bagi mereka yang tidak mengerti sedikit bagaimana tepatnya melalui kode operasi CRUD dengan Entitas dapat dilakukan.

Entitas dalam DialogFlow


Entitas DialogFlow adalah beberapa entitas yang terdiri dari ReferenceValue dan Sinonim. Sesuatu yang mirip dengan nilai kunci, hanya dengan perbedaan bahwa ada banyak sinonim, dan semakin banyak ada, semakin baik, karena itu "menyederhanakan kehidupan bot" dan lebih mudah baginya untuk memahami nilai apa yang sedang dibicarakan, dan tanda centang Pencocokan fuzzy akan membantu bot juga memahami apa yang dipertaruhkan, bahkan jika Anda melewatkan satu huruf atau simbol lainnya. Itu terlihat seperti ini:

Moskow - Moskow, Moskow, Moskow ...

Menyelesaikan perjalanan singkat, saya ingin menambahkan bahwa dengan Entity ada banyak keributan. Tentu saja, saya tidak mengurangi arti niat, dan sebagainya, tetapi faktanya tetap.

Jenis Entitas


Inilah jebakan pertama, meskipun kecil, bagi saya. Lagipula, dokumentasi memiliki metode untuk bekerja dengan Entity, dan ada metode untuk bekerja dengan EntityType - yang mana di antaranya adalah apa?

Faktanya, semuanya tidak begitu rumit, hanya timbul kebingungan karena fakta bahwa dalam DialogFlow sendiri tab dengan EntityTypes disebut Entitas:

gambar

EntityType: gambar

Entitie: gambar

Meskipun diyakini DialogFlow sendiri bahwa ada Entity dan memiliki Entri (mis. Esensi dan entri di dalamnya).

Mari kita lanjutkan.

Anda dapat membuat EntityType secara manual langsung di DialoFlow, tetapi saya akan menunjukkan bagaimana hal ini dapat dilakukan melalui kode (setelah semua, untuk membuat Entitas kita perlu tahu di mana EntityType itu).

Pertama, aktifkan paket NuGet Google.Cloud.Dialogflow.V2. Pada saat penulisan, versi 1.1.0 diinstal:

gambar

Pertama kita membuat kelas dan menyebutnya EntityTypeManagement di mana akan ada operasi dasar:

using Google.Api.Gax;
using Google.Cloud.Dialogflow.V2;

public class EntityTypeManagement
    {
      //Create -   EntityType   Test1 (  ) 
      //projectId - Id    DialogFlow
      //displayName -         
        public async Task Create(string projectId, string displayName, EntityType.Types.Kind kind = 
      EntityType.Types.Kind.Map)
        {
            var client = await EntityTypesClient.CreateAsync();

            var entityType = new EntityType();
            entityType.DisplayName = displayName;
            entityType.Kind = kind;

            var createdEntityType = client.CreateEntityType(
                parent: new ProjectAgentName(projectId),
                entityType: entityType
            );

            Console.WriteLine($"Created EntityType: {createdEntityType.Name}");
        }
       
      //List -   EntityTypes   
      //projectId - Id    DialogFlow
        public async Task<PagedEnumerable<ListEntityTypesResponse,EntityType>> List(string projectId)
        {
            var client = await EntityTypesClient.CreateAsync();
            var response = client.ListEntityTypes(
                parent: new ProjectAgentName(projectId)
            );
            return response;
        }

       //GetEntityTypeId -  EntityType  
       //projectId - Id    DialogFlow
       //targetEventTypeName -  EntityType,    
        public async Task<string> GetEntityTypeId(string projectId,string targetEventTypeName)
        {
            var client = await EntityTypesClient.CreateAsync();
            var response = client.ListEntityTypes(
                parent: new ProjectAgentName(projectId)
            );
            string id = response.Where(x => x.DisplayName == targetEventTypeName).FirstOrDefault().Name;
            string returningId = id.Replace($"projects/{projectId}/agent/entityTypes/", "");
            return returningId;
        }

       //Delete  BatchDelete      EntityType
       //   entityTypeId
        public async Task Delete(string projectId, string entityTypeId)
        {
            var client = await EntityTypesClient.CreateAsync();

            client.DeleteEntityType(new EntityTypeName(projectId, entityTypeId: entityTypeId));

            Console.WriteLine($"Deleted EntityType: {entityTypeId}");

        }

        
        public async Task BatchDelete(string projectId, IEnumerable<string> entityTypeIds)
        {
            var client = await EntityTypesClient.CreateAsync();
            var entityTypeNames = entityTypeIds.Select(
                id => new EntityTypeName(projectId, id).ToString());
            client.BatchDeleteEntityTypes(new ProjectAgentName(projectId),
                entityTypeNames);
        }
    }

Di sini harus segera dikatakan bahwa tidak ada fungsi Perbarui hanya karena Buat sudah menjalankan fungsinya.

Sekarang kita memiliki metode dasar untuk bekerja dengan EntityTypes, mari beralih ke Entity dan segera buat kelas EntityManagement:

public class EntityManagement
    {
       using Google.Cloud.Dialogflow.V2;        


      //Create -    Entity
      //entityTypeId - Id EntityType      Entity
      //entityValue - ReferenceValue  Entity
      // synonyms -    Entity
        public async Task Create(string projectId,
                                 string entityTypeId,
                                 string entityValue,
                                 string[] synonyms)
        {
            var client = await EntityTypesClient.CreateAsync();
            var entity = new EntityType.Types.Entity() { Value = entityValue};
            entity.Synonyms.AddRange(synonyms);
            
            var operation = await client.BatchCreateEntitiesAsync(
                parent: new EntityTypeName(projectId, entityTypeId),
                entities: new[] { entity }
            ); 
            operation.PollUntilCompleted();
        }

       //CreateMany -   Entities 
       //entityTypeId - Id EntityType      Entity
       //entities -  Entities  
        public async Task CreateMany(string projectId,string entityTypeId, IEnumerable<Entity> entities)
        {
            var client = await EntityTypesClient.CreateAsync();
            List<EntityType.Types.Entity> results = new List<EntityType.Types.Entity>();
            foreach (var item in entities)
            {
                var entity = new EntityType.Types.Entity() { Value = item.value };
                entity.Synonyms.AddRange(item.synonyms);
                results.Add(entity);
            }
           
            var operation = await client.BatchCreateEntitiesAsync(
                parent: new EntityTypeName(projectId, entityTypeId),
                entities: results.ToArray());
            operation.PollUntilCompleted();
        }

      //Delete -    Entity,   "string entityValue"   
     //string[] entityValue      entityValues: entityValue
     //    .
        public async Task Delete(string projectId, string entityTypeId, string entityValue)
        {
            var client = await EntityTypesClient.CreateAsync();

            var operation = await client.BatchDeleteEntitiesAsync(
                parent: new EntityTypeName(projectId, entityTypeId),
                entityValues: new[] { entityValue }
            );

            Console.WriteLine("Waiting for the entity deletion operation to complete.");
            operation.PollUntilCompleted();

            Console.WriteLine($"Deleted Entity: {entityValue}");

        }
        
      //List -   Entities  EntityType 
     public async Task<List<Entity>> List(string projectId, string entityTypeId)
        {
            var client = await EntityTypesClient.CreateAsync();
            var entityType = await client.GetEntityTypeAsync(new EntityTypeName(
                projectId, entityTypeId
            ));
            List<Entity> EntitiesList = new List<Entity>();
            
            foreach (var entity in entityType.Entities)
            {
                List<string> Synonyms = new List<string>();
                foreach (var item in entity.Synonyms)
                {
                    Synonyms.Add(item);
                }
                EntitiesList.Add(new Entity { value = entity.Value, synonyms = Synonyms.ToArray() });
                Synonyms = null;
            }

            return EntitiesList;
        }
    }

Tambahkan model kami yang akan mewakili Entitas:

public class Entity
    {
        public string value { get; set; }
        public string[] synonyms { get; set; }
    }

Selesai, semua fitur dasar CRUD sudah siap. Sekali lagi, kembali ke Pembaruan, ini dapat diimplementasikan secara terpisah, tetapi tidak diperlukan, karena Buat berfungsi seperti Pembaruan juga.

Contohnya cukup sederhana dan, saya harus setuju, masih ada "hardcode", tapi saya harap artikel ini bermanfaat bagi mereka yang, seperti saya, tidak dapat menemukan cara melakukan operasi CRUD dengan benar melalui kode.

static void Main(string[] args)
        {
      EntityTypesManagement entityTypesManagement = new EntityTypesManagement();
      EntityManagement entityManagement = new EntityManagement();
       string ProjectId = "Your Project`s id";
       string EntityName = "Your EntityName";
      var entityId = await entityTypesManagement.GetEntityTypeId(ProjectId, EntityName);
       Entity entity =  new Entity{value = "1", synonyms = new[]{"1","1"}};
      /*await*/ entityManagement.Create(ProjectId,entityId,entity);
 }

Source: https://habr.com/ru/post/undefined/

More articles:


All Articles