public void SyncWatsonConversation(LexiconWorkspace workspace, WorkspaceSyncData syncData)
        {
            workspace.WatsonConversationManager.IsSyncing  = true;
            workspace.WatsonConversationManager.SyncStatus = "Syncing";

            WatsonSyncQueue syncQueue = ScriptableObject.CreateInstance <WatsonSyncQueue>();

            syncQueue.workspace = workspace;
            syncQueue.syncData  = syncData;

            if (string.IsNullOrEmpty(workspace.WatsonConversationManager.WorkspaceId))
            {
                syncQueue.Enqueue(WatsonWorkspaceCreate.CreateInstance(workspace));
            }

            syncQueue.Enqueue(WatsonIntentSyncAll.CreateInstance(workspace));
            syncQueue.Enqueue(WatsonEntitySyncAll.CreateInstance(workspace));

            syncQueue.OnCompleteAction = WatsonCompleteConversationSync.CreateInstance(workspace);
            syncQueue.OnQueueFinished += CleanUp;

            syncQueue.Process();

            watsonConversationSyncQueues.Add(syncQueue);
        }
        public void SyncWatsonSpeechToText(LexiconWorkspace workspace, WorkspaceSyncData syncData)
        {
            workspace.WatsonSpeechToTextManager.IsSyncing  = true;
            workspace.WatsonSpeechToTextManager.SyncStatus = "Syncing";

            WatsonSyncQueue syncQueue = ScriptableObject.CreateInstance <WatsonSyncQueue>();

            syncQueue.workspace = workspace;
            syncQueue.syncData  = syncData;

            if (string.IsNullOrEmpty(workspace.WatsonSpeechToTextManager.CustomizationId))
            {
                syncQueue.Enqueue(WatsonCustomModelCreate.CreateInstance(workspace));
            }
            else
            {
                syncQueue.Enqueue(WatsonCustomWordsUpdate.CreateInstance(workspace));
                syncQueue.Enqueue(TimerSyncAction.CreateInstance(10));
            }

            syncQueue.Enqueue(WatsonCorpusAddIntents.CreateInstance(workspace));
            syncQueue.Enqueue(TimerSyncAction.CreateInstance(10));
            syncQueue.Enqueue(WatsonCorpusAddEntities.CreateInstance(workspace));
            syncQueue.Enqueue(TimerSyncAction.CreateInstance(10));
            syncQueue.Enqueue(WatsonCustomModelTrain.CreateInstance(workspace));
            syncQueue.Enqueue(TimerSyncAction.CreateInstance(10));

            syncQueue.OnCompleteAction = WatsonCompleteSpeechToTextSync.CreateInstance(workspace);
            syncQueue.OnQueueFinished += CleanUp;

            syncQueue.Process();

            watsonSpeechToTextSyncQueues.Add(syncQueue);
        }
        public void MonitorWatsonSpeechToTextTraining(LexiconWorkspace workspace)
        {
            workspace.WatsonSpeechToTextManager.IsTraining = true;

            WatsonSyncQueue syncQueue = ScriptableObject.CreateInstance <WatsonSyncQueue>();

            syncQueue.workspace = workspace;

            syncQueue.Enqueue(WatsonCustomModelStatus.CreateInstance(workspace));
            syncQueue.Enqueue(WatsonCustomWordsGet.CreateInstance(workspace));

            syncQueue.OnCompleteAction = WatsonCompleteSpeechToTextTraining.CreateInstance(workspace);
            syncQueue.OnQueueFinished += CleanUp;

            syncQueue.Process();

            watsonSpeechToTextSyncQueues.Add(syncQueue);
        }
        public void MonitorWatsonConversationTraining(LexiconWorkspace workspace)
        {
            workspace.WatsonConversationManager.IsTraining = true;

            WatsonSyncQueue syncQueue = ScriptableObject.CreateInstance <WatsonSyncQueue>();

            syncQueue.workspace = workspace;

            syncQueue.Enqueue(WatsonWorkspaceStatus.CreateInstance(workspace));

            syncQueue.OnCompleteAction = WatsonCompleteConversationTraining.CreateInstance(workspace);
            syncQueue.OnQueueFinished += CleanUp;

            syncQueue.Process();

            watsonConversationSyncQueues.Add(syncQueue);
        }
Exemplo n.º 5
0
        void HandleSuccessCallback(ListIntentsResp intentsResp, Dictionary <string, object> customData)
        {
            if (intentsResp == null)
            {
                succeeded = false;
                isDone    = true;
                return;
            }

            WorkspaceSyncData syncData = queue.syncData;

            HashSet <string> watsonIntentNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase);

            foreach (Intent watsonIntent in intentsResp.intents)
            {
                string     intentName = watsonIntent.intent;
                IntentData localIntent;

                if (syncData.intentData.TryGetValue(intentName, out localIntent))
                {
                    string localTimestamp = workspace.WatsonConversationManager.Timestamps.GetIntentTimestamp(intentName);
                    bool   needsUpdate    = true;

                    if (watsonIntent.updated.Equals(localTimestamp, StringComparison.OrdinalIgnoreCase))
                    {
                        // No remote changes

                        if (workspace.WatsonConversationManager.LastSyncData != null)
                        {
                            IntentData lastSync;
                            if (workspace.WatsonConversationManager.LastSyncData.intentData.TryGetValue(intentName, out lastSync))
                            {
                                if (WorkspaceSyncData.CompareIntentData(localIntent, lastSync))
                                {
                                    // No local changes
                                    needsUpdate = false;
                                }
                            }
                        }
                    }

                    if (needsUpdate)
                    {
                        queue.Enqueue(WatsonIntentUpdate.CreateInstance(workspace, localIntent));
                    }
                }
                else
                {
                    // Intent deleted locally
                    queue.Enqueue(WatsonIntentDelete.CreateInstance(workspace, intentName));
                }

                watsonIntentNames.Add(intentName);
            }

            foreach (IntentData localIntent in syncData.intentData.Values)
            {
                if (!watsonIntentNames.Contains(localIntent.name))
                {
                    // Intent does not exist on server
                    queue.Enqueue(WatsonIntentCreate.CreateInstance(workspace, localIntent));
                }
            }

            succeeded = true;
            isDone    = true;
        }
        void HandleSuccessCallback(ListEntitiesResp entitiesResp, Dictionary <string, object> customData)
        {
            if (entitiesResp == null)
            {
                succeeded = false;
                isDone    = true;
                return;
            }

            WorkspaceSyncData syncData = queue.syncData;

            HashSet <string> watsonEntityNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase);

            foreach (Entity watsonEntity in entitiesResp.entities)
            {
                string     entityName = watsonEntity.entity;
                EntityData localEntity;

                if (syncData.entityData.TryGetValue(entityName, out localEntity))
                {
                    string localTimestamp = workspace.WatsonConversationManager.Timestamps.GetEntityTimestamp(entityName);
                    bool   needsUpdate    = true;

                    if (watsonEntity.updated.Equals(localTimestamp, StringComparison.OrdinalIgnoreCase))
                    {
                        // No remote changes

                        if (workspace.WatsonConversationManager.LastSyncData != null)
                        {
                            EntityData lastSync;
                            if (workspace.WatsonConversationManager.LastSyncData.entityData.TryGetValue(entityName, out lastSync))
                            {
                                if (WorkspaceSyncData.CompareEntityData(localEntity, lastSync))
                                {
                                    // No local changes
                                    needsUpdate = false;
                                }
                            }
                        }
                    }

                    if (needsUpdate)
                    {
                        queue.Enqueue(WatsonEntityUpdate.CreateInstance(workspace, localEntity));
                    }
                }
                else
                {
                    // Entity deleted locally
                    queue.Enqueue(WatsonEntityDelete.CreateInstance(workspace, entityName));
                }

                watsonEntityNames.Add(entityName);
            }

            foreach (EntityData localEntity in syncData.entityData.Values)
            {
                if (!watsonEntityNames.Contains(localEntity.name))
                {
                    // Entity does not exist on server
                    queue.Enqueue(WatsonEntityCreate.CreateInstance(workspace, localEntity));
                }
            }

            succeeded = true;
            isDone    = true;
        }