script

Mit diesem Script werden Navigatoren automatisch mit der aktuellen Selektion synchronisiert.
Vielen Dank an FrankS für das Erstellen 💖

Achtung: Je nachdem wie viele Navigatoren geöffnet sind und wie groß das Projekt ist, kann sich das Script negativ auf die Perfomance auswirken.

// AutoSyncNavis.cs
//
// Nachdem das Script geladen wurde kann das Synchronisieren aller Navigatoren mit dem
// ausgewählten Element im GED aktiviert werden.
//
// Es wird ein neuer Menüpunkt "AutoSync Navigatoren" in der Gruppe "Erweiterung" im Tab "Ansicht" angelegt,
// außerdem wird die aktuelle Einstellung gespeichert.
//
// Copyright by Frank Schöneck, 2024
//
// letzte Änderung:
// V1.0.0, 23.07.2024, Frank Schöneck, Projektbeginn

using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Base;
using Eplan.EplApi.Gui;
using Eplan.EplApi.Scripting;
using System.Linq;

public class AutoSyncNavis
{
    private string sSettingName = "USER.SCRIPTS.AutoSyncNavis.AutoSyncState";

    //RibbonBar Einträge definieren
    string m_TabName = "Ansicht";
    string m_commandGroupName = "Erweiterungen";
    string m_commandName = "AutoSync";
    string m_SVGstringIconNavigator = @"<svg fill='#464646' height='800px' width='800px' version='1.1' id='XMLID_85_' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' viewBox='0 0 24 24' enable-background='new 0 0 24 24' xml:space='preserve'>
        <path d='M21,24h-6v-6h6V24z M17,22h2v-2h-2V22z M15,22H6V8H3V0h8v8H8v4h7v2H8v6h7V22z M5,6h4V2H5V6z M21,16h-6v-6h6V16z M17,14h2 v-2h-2V14z'/>
        </svg>";


    [DeclareRegister]
    public void registerRibbonItems()
    {
        RibbonBar ribbonBar = new RibbonBar();
        var newTab = new Eplan.EplApi.Gui.RibbonBar().Tabs.FirstOrDefault(item => item.Name == m_TabName);
        if (newTab == null) //Tab noch nicht vorhanden, dann neu erzeugen
        {
            newTab = new Eplan.EplApi.Gui.RibbonBar().AddTab(m_TabName);
        }
        var commandGroup = newTab.CommandGroups.FirstOrDefault(item => item.Name == m_commandGroupName);
        if (commandGroup == null) //CommandGroup noch nicht vorhanden, dann neu erzeugen
        {
            commandGroup = newTab.AddCommandGroup(m_commandGroupName);
        }
        RibbonIcon ribbonIconNavigator = ribbonBar.AddIcon(m_SVGstringIconNavigator); //Icon festlegen
        commandGroup.AddCommand(m_commandName, "AutoSyncNavis", m_commandName, "AutoSync der Navigatoren ein- / ausschalten", ribbonIconNavigator);
    }

    [DeclareUnregister]
    public void unRegisterRibbonItems()
    {
        //Command entfernen
        var vTab = new Eplan.EplApi.Gui.RibbonBar().Tabs.FirstOrDefault(item => item.Name == m_TabName);
        if (vTab != null)
        {
            var commandGroup = vTab.CommandGroups.FirstOrDefault(item => item.Name == m_commandGroupName);
            if (commandGroup != null)
            {
                var command = commandGroup.Commands.Values.FirstOrDefault(item => item.Text == m_commandName);
                if (command != null)
                {
                    command.Remove();
                }
                //Wenn CommandGroup leer ist diese auch entfernen
                if (commandGroup.Commands.Count == 0)
                {
                    commandGroup.Remove();
                }
            }
            //Wenn Tab leer ist dieses auch entfernen
            if (vTab.Commands.Count == 0)
            {
                vTab.Remove();
            }
        }
        //Einstellungen löschen
        DeleteSettings();

    }

    [DeclareAction("AutoSyncNavis")]
    public void AutoSyncNavisAction()
    {
        Settings oSettings = new Settings();

        string sAutoSyncState = string.Empty;
        if (oSettings.ExistSetting(sSettingName))
        {
            sAutoSyncState = oSettings.GetStringSetting(sSettingName, 0);
        }

        //Prüfen ob AutoSync aktiviert ist
        if (sAutoSyncState == string.Empty | sAutoSyncState.ToUpper() != "ON")
        {
            //nicht aktiviert
            Decider eDecision = new Decider();
            EnumDecisionReturn eAnswer = eDecision.Decide(
                EnumDecisionType.eYesNoDecision,
                "Soll das Auto-Synchronisieren der Navigatoren eingeschaltet werden?",
                "AutoSyncNavis",
                EnumDecisionReturn.eYES,
                EnumDecisionReturn.eNO,
                string.Empty,
                false,
                EnumDecisionIcon.eQUESTION);
            if (eAnswer == EnumDecisionReturn.eYES)
            {
                //Einstellung speichern
                SetSettings("ON");
            }
        }
        else
        {
            Decider eDecision = new Decider();
            EnumDecisionReturn eAnswer = eDecision.Decide(
                EnumDecisionType.eYesNoDecision,
                "Soll das Auto-Synchronisieren der Navigatoren ausgeschaltet werden?",
                "AutoSyncNavis",
                EnumDecisionReturn.eYES,
                EnumDecisionReturn.eNO,
                string.Empty,
                false,
                EnumDecisionIcon.eQUESTION);
            if (eAnswer == EnumDecisionReturn.eYES)
            {
                //Einstellung speichern
                SetSettings("OFF");
            }
        }
        return;
    }

    //Einstellungen speichern
    private void SetSettings(string AutoSyncActive)
    {
        Settings oSettings = new Settings();
        if (!oSettings.ExistSetting(sSettingName))
        {
            oSettings.AddStringSetting(sSettingName,
                new string[] { },
                new string[] { },
                ISettings.CreationFlag.Insert);
        }
        oSettings.SetStringSetting(sSettingName, AutoSyncActive, 0);
    }

    //Einstellungen löschen
    public void DeleteSettings()
    {
        Settings oSettings = new Settings();
        if (oSettings.ExistSetting(sSettingName))
        {
            oSettings.DeleteSetting(sSettingName);
            new Decider().Decide(EnumDecisionType.eOkDecision,
                "Die Einstellung [" + sSettingName + "] wurde gelöscht.",
                "AutoSyncNavis",
                EnumDecisionReturn.eOK,
                EnumDecisionReturn.eOK,
                string.Empty,
                false,
                EnumDecisionIcon.eINFORMATION);
        }
        else
        {
            new Decider().Decide(EnumDecisionType.eOkDecision,
                "Die Einstellungen wurden nicht gefunden!",
                "AutoSyncNavis",
                EnumDecisionReturn.eOK,
                EnumDecisionReturn.eOK,
                string.Empty,
                false,
                EnumDecisionIcon.eFATALERROR);
        }
    }

    //Eine Element wurde markiert
    [DeclareEventHandler("onSelChanged")]
    public void MyEventOnSelChanged()
    {
        Settings oSettings = new Settings();
        string sAutoSyncState = string.Empty;
        if (oSettings.ExistSetting(sSettingName))
        {
            sAutoSyncState = oSettings.GetStringSetting(sSettingName, 0);
        }

        //Prüfen ob AutoSync aktiviert ist
        if (sAutoSyncState == string.Empty | sAutoSyncState.ToUpper() != "ON")
        {
            //Keine Aktion ausführen
            return;
        }
        else
        {
            //Setting existiert und AutoSync soll aktiviert werden
            new CommandLineInterpreter().Execute("XEsSyncPDDsAction");
        }
        return;
    }

    //Prüft ob Eplan gestartet wurde
    [DeclareEventHandler("Eplan.EplApi.OnMainStart")]
    public void MyEventEplanStart()
    {
        Settings oSettings = new Settings();
        string sAutoSyncState = string.Empty;

        //War AutoSync beim letzten mal aktiv?
        if (oSettings.ExistSetting(sSettingName))
        {
            sAutoSyncState = oSettings.GetStringSetting(sSettingName, 0);

            //wenn ja ("ON") dann AutoSync aktivieren
            if (sAutoSyncState.ToUpper() == "ON")
            {
                new CommandLineInterpreter().Execute("XEsSyncPDDsAction");
            }
        }
        return;
    }
}

Auch still und heimlich kam eine neue Action hinzu: XPartsSetDataSourceAction.
Mit dieser Action kann schnell und einfach die aktive Artikeldatenbank eingestellt werden.

Ihr findet alle Parameter mit Beschreibung hier in der EPLAN Hilfe.

Lokale Datenbank

XPartsSetDataSourceAction /DataSourceType:0 /DataBaseFileName:C:\Users\Public\EPLAN\Data\Article\COMPANY_NAME\Database.alk

SQL Datenbank: Windows Authentifizierung

XPartsSetDataSourceAction /DataSourceType:1 /SqlLogin:0 /SqlServer:SQL_SERVER_NAME /SqlCatalog:SQL_DATABASE

SQL Datenbank: SQL Authentifizierung

XPartsSetDataSourceAction /DataSourceType:1 /SqlLogin:1 /SqlServer:SQL_SERVER_NAME /SqlCatalog:SQL_DATABASE /SqlUserName:SQL_USERNAME /SqlPassword:SQL_PASSWORD

eStock

XPartsSetDataSourceAction /DataSourceType:3 /CollectionName:ESTOCK_COLLECTION_NAME /CollectionId:ESTOCK_COLLECTION_ID

Es hat genau einen Tag gedauert, seit EPLAN Newtonsoft.Json unterstützt, bis mein grandioser Kollege Daniel ein Script für EPLAN gebastelt hat, dass die fehlenden Übersetzungen im Wörterbuch mit DeepL übersetzt.

Das Script exportiert erstmal alle fehlenden Übersetzungen im Projekt (Quellsprache Deutsch).
Frägt dann die pro Eintrag die DeepL API nach einer Übersetzung (English).
Die Ergebnisse werden dann in einer XML-Datei gespeichert und angezeigt.

Diese Datei kann dann ins Wörterbuch importiert werden.

Vorraussetzung ist ein API-Key, welcher in der Windows Variable DEEPL_API_KEY gespeichert ist.

Orginal-Script findet Ihr auf GitHub.
Vielen Dank Daniel 💖

using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using System.Net.Http;
using System.Windows.Forms;
using System.Xml.Serialization;
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Base;
using Eplan.EplApi.Scripting;

namespace TranslateWithDeepl
{
  public class TranslateWithDeepl
  {
    private readonly string _apiKey;
    private readonly string _url = "https://api-free.deepl.com/v2/translate";
    private readonly HttpClient _httpClient;

    [Start]
    public async void Execute(ActionCallingContext context)
    {
      var missingTerms = GetMissingTerms();
      await TranslateTerms(missingTerms);
    }

    private async Task TranslateTerms(EplanLanguageDbRoot missingTerms)
    {
      var requestDto = new RequestDto();
      requestDto.TargetLang = "EN";
      requestDto.Text = missingTerms.TextSection.MT.SelectMany(mt => mt.T).Where(t => t.Lang == "de_DE").Select(t => t.Text).ToArray();
      var translate = await Translate(requestDto);
      
      for(int i = 0; i < missingTerms.TextSection.MT.Length; i++)
      {
        missingTerms.TextSection.MT[i].T.First(t => t.Lang == "en_US").Text = translate.Translations[i].Text;
      }
      
      var projectDoc = PathMap.SubstitutePath("$(DOC)");
      var fileName = Path.Combine(projectDoc, "TranslatedTerms.xml");
      var serializer = new XmlSerializer(typeof(EplanLanguageDbRoot));
      using (var writer = new StreamWriter(fileName))
      {
        serializer.Serialize(writer, missingTerms);
      }
      
      Process.Start(fileName);
    }

    public EplanLanguageDbRoot GetMissingTerms()
    {
      var xmlFile = Path.GetTempFileName();
      var context = new ActionCallingContext();
      context.AddParameter("TYPE", "EXPORTMISSINGTRANSLATIONS");
      context.AddParameter("LANGUAGE", "en_US");
      context.AddParameter("EXPORTFILE", xmlFile);
      context.AddParameter("CONVERTER", "XTrLanguageDbXmlConverterImpl");
      new CommandLineInterpreter().Execute("translate", context);
      
      var serializer = new XmlSerializer(typeof(EplanLanguageDbRoot));
      EplanLanguageDbRoot eplanLanguageDbRoot = null;
      
      using (var reader = new StreamReader(xmlFile))
      {
        eplanLanguageDbRoot = (EplanLanguageDbRoot)serializer.Deserialize(reader);
      }
      return eplanLanguageDbRoot;
    }

    public TranslateWithDeepl()
    {
      // get api key from %DEEPL_API_KEY% environment variable
      _apiKey = System.Environment.GetEnvironmentVariable("DEEPL_API_KEY");
      _httpClient = new HttpClient();
    }

    private async Task<string> Translate(string text, string targetLang)
    {
      var translateDto = new RequestDto
      {
        Text = new string[] { text },
        TargetLang = targetLang
      };

      ResponseDto responseDto = await Translate(translateDto);
      return responseDto.Translations[0].Text;
    }

    private async Task<ResponseDto> Translate(RequestDto translateDto)
    {
      var json = JsonConvert.SerializeObject(translateDto);
      var data = new StringContent(json, Encoding.UTF8, "application/json");

      _httpClient.DefaultRequestHeaders.Add("Authorization", string.Format("DeepL-Auth-Key {0}", _apiKey));

      var response = await _httpClient.PostAsync(_url, data);
      var result = await response.Content.ReadAsStringAsync();
      ResponseDto responseDto = JsonConvert.DeserializeObject<ResponseDto>(result);

      return responseDto;
    }
  }

  public class ResponseDto
  {
    [JsonProperty("translations")]
    public TranslationDto[] Translations { get; set; }
  }

  public class TranslationDto
  {
    [JsonProperty("detected_source_language")]
    public string DetectedSourceLanguage { get; set; }

    [JsonProperty("text")]
    public string Text { get; set; }
  }

  public class RequestDto
  {
    [JsonProperty("text")]
    public string[] Text { get; set; }

    [JsonProperty("target_lang")]
    public string TargetLang { get; set; }
  }

  [XmlRoot(ElementName = "EplanLanguageDbRoot")]
  public class EplanLanguageDbRoot
  {
    [XmlAttribute(AttributeName = "Languages")]
    public string Languages { get; set; }

    [XmlAttribute(AttributeName = "numTexts")]
    public int NumTexts { get; set; }

    [XmlAttribute(AttributeName = "numTerms")]
    public int NumTerms { get; set; }

    [XmlAttribute(AttributeName = "numNonTranslate")]
    public int NumNonTranslate { get; set; }

    [XmlElement(ElementName = "TextSection")]
    public TextSection TextSection { get; set; }
  }

  public class TextSection
  {
    [XmlElement(ElementName = "MT")]
    public MT[] MT { get; set; }
  }

  public class MT
  {
    [XmlElement(ElementName = "T")]
    public T[] T { get; set; }
  }

  public class T
  {
    [XmlAttribute(AttributeName = "xml:lang")]
    public string Lang { get; set; }

    [XmlText]
    public string Text { get; set; }
  }
}

Anbei mal Beispiele um mit JSON zu arbeiten.

Product product = new Product();
product.Name = "Apple";
product.Expiry = new DateTime(2008, 12, 28);
product.Sizes = new string[] { "Small" };

string json = JsonConvert.SerializeObject(product);
// {
//   "Name": "Apple",
//   "Expiry": "2008-12-28T00:00:00",
//   "Sizes": [
//     "Small"
//   ]
// }

string json = @"{
  'Name': 'Bad Boys',
  'ReleaseDate': '1995-4-7T00:00:00',
  'Genres': [
    'Action',
    'Comedy'
  ]
}";

Movie m = JsonConvert.DeserializeObject<Movie>(json);

string name = m.Name;
// Bad Boys