BeWoPlaner/Service/ai/TranscriptionService.cs

using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Data.Security;
using BeWo.Service.OwnChat;
using BS.Shared.DataContracts;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace BeWo.Service.AI
{
    public class TranscriptionService
    {
        public AiVoiceData StartTranskription(String tenant, String sprache = "de")
        {

            AiVoiceData avd = null;

            try
            {
#if DEBUG
                avd = new AiVoiceData();
                avd.StatusMessage = "1";
                DAOFactory.GenericDAO.Update(avd);

                return avd;
#endif

                avd = GetTranskriptionToken(tenant, sprache);

                if (!String.IsNullOrEmpty(avd.Token))
                {
                    var url = String.Format("ownchat://voice/?token={0}", avd.Token);
                    var msg = String.Format("Bitte klicken Sie auf folgenden Link um die Aufnahme zu starten:\n\n{0}", url);
                    
                    OwnChatHelper.SendOwnChatMessage(msg, UserRightHelper.GetLoggedInUser().Employee);
                }

                return avd;
            }
            catch (Exception e)
            {
                if (avd == null)
                {
                    avd = new AiVoiceData();
                }
                avd.Error = e.Message;
                return avd;
            }
        }

        public AiVoiceData GetTranskription(AiVoiceData avd)
        {

            try
            {

#if DEBUG
                if (!String.IsNullOrEmpty(avd.StatusMessage) && Int32.TryParse(avd.StatusMessage, out var test))
                {
                    test++;
                    avd.StatusMessage = String.Format("{0}", test);
                }
#endif
                if (!String.IsNullOrEmpty(avd.ResultUrl))
                {
                    if (CheckValidUrl(avd.ResultUrl))
                    {
                        WebRequest request = WebRequest.Create(avd.ResultUrl);
                        request.Credentials = CredentialCache.DefaultCredentials;

                        using (var response = request.GetResponse())
                        {
                            var responseString = ReadStringFromResponse(response);

                            var jsonDef = new { result = "", token = "", transcription = "", transcription_started_at = "", transcription_finished_at = "", state = "", callback_result = "" };

                            var json = JsonConvert.DeserializeAnonymousType(responseString, jsonDef);

                            avd.Result = json.result;
                            avd.Token = json.token;
                            avd.TranskriptionText = json.transcription;
                            avd.Status = json.state;

                            if (json.result == "20" && json.state == "0")
                            {
                                avd.StatusMessage = "Um die Aufnahme zu starten, klicken Sie auf den Link, den wir an Ihren ownChat Account gesendet haben.";
                            }
                            else if (json.result == "0" && json.state == "10")
                            {
                                avd.StatusMessage = "Die Aufnahme wurde erfolgreich hochgeladen und wird gerade transkribiert";
                            }
                            else if (json.result == "0" && json.state == "20")
                            {
                                avd.StatusMessage = "Die Transkription läuft gerade";
                            }
                            else if (json.result == "0" && json.state == "30")
                            {
                                avd.StatusMessage = "Transkription erfolgreich abgeschlossen";
                                DAOFactory.GenericDAO.Update(avd);
                            }
                            else
                            {
                                avd.StatusMessage = String.Format("Es ist leider ein Fehler aufgetreten: Result = {0}, Status = {1}", json.result, json.state);
                                DAOFactory.GenericDAO.Update(avd);
                            }
                        }
                    }
                }


                return avd;
            }
            catch (Exception e)
            {
                avd.Error = e.Message;
                return avd;

            }
        }

        private bool CheckValidUrl(String url)
        {
            string pattern = @"^https:\/\/.{1,3}\.ownsoft\.de\/.*$";

            return Regex.IsMatch(url, pattern);
        }

        private AiVoiceData GetTranskriptionToken(String tenant, String sprache)
        {

            try
            {
                var serverUrl = OwnChatHelper.ErmittleServerURL("4", tenant);

                if (!String.IsNullOrEmpty(serverUrl))
                {

                    var endurl = String.Format("{0}/api/token/{1}/{2}", serverUrl, sprache, tenant);

                    WebRequest request = WebRequest.Create(endurl);
                    request.Credentials = CredentialCache.DefaultCredentials;

                    using (var response = request.GetResponse())
                    {
                        var responseString = ReadStringFromResponse(response);

                        var jsonDef = new { result = "", token = "", upload_url = "", result_url = "" };

                        var json = JsonConvert.DeserializeAnonymousType(responseString, jsonDef);

                        var avd = new AiVoiceData();
                        avd.Result = json.result;
                        avd.Token = json.token;
                        avd.UploadUrl = json.upload_url;
                        avd.ResultUrl = json.result_url;

                        return avd;
                    }

                }
                return null;
            }
            catch (Exception e)
            {
                return null;

            }
        }

        private string ReadStringFromResponse(WebResponse response)
        {
            try
            {
                using (Stream dataStream = response.GetResponseStream())
                {
                    using (StreamReader reader = new StreamReader(dataStream))
                    {
                        string responseFromServer = reader.ReadToEnd();

                        return responseFromServer;
                    }
                }
            }
            catch (Exception e)
            {
                return null;
            }
        }

        public AiVoiceDataDC MapAiVoiceDataDC(AiVoiceData data)
        {
            return new AiVoiceDataDC
            {
                Error = data.Error,
                Result = data.Result,
                ResultUrl = data.ResultUrl,
                Status = data.Status,
                StatusMessage = data.StatusMessage,
                Token = data.Token,
                TranskriptionText = data.TranskriptionText,
                UploadUrl = data.UploadUrl
            };
        }

        public AiVoiceData MapAiVoiceData(AiVoiceDataDC data)
        {
            return new AiVoiceData
            {
                Error = data.Error,
                Result = data.Result,
                ResultUrl = data.ResultUrl,
                Status = data.Status,
                StatusMessage = data.StatusMessage,
                Token = data.Token,
                TranskriptionText = data.TranskriptionText,
                UploadUrl = data.UploadUrl
            };
        }
    }
}