public async Task Filter()
        {
            var groupShareClient = await Helper.GetGroupShareClient();

            //      var languageDetails = new LanguageDetailsRequest("Europäischen", "de-de", "Acord ", "ro-ro");
            var languageDetails = new LanguageDetailsRequest("", "de-de", "Informare", "ro-ro");
            var tmDetails       = new TranslationMemoryDetailsRequest(new Guid("27782e18-a0df-4266-ac9f-29965d3a3638"), 0, 50);

            var filter = await groupShareClient.TranslationMemories.FilterAsPlainText(languageDetails, tmDetails, true, true);

            foreach (var segment in filter)
            {
                Assert.Contains("Informare", segment.Target);
            }
        }
Beispiel #2
0
        public static string CreateFilter(LanguageDetailsRequest languageRequest, bool caseSensitive, bool useWildCards)
        {
            var sourceFieldExpression = string.Empty;
            var targetFieldExpression = string.Empty;
            var expression            = string.Empty;

            //Create source expression
            if (!string.IsNullOrEmpty(languageRequest.SourceText))
            {
                var sourceExpr       = EscapeCharacters(languageRequest.SourceText, caseSensitive, useWildCards);
                var sourceFieldValue = new ExpressionFieldValue
                {
                    Name     = "src",
                    Operator = "~",
                    Value    = sourceExpr
                };
                sourceFieldExpression = sourceFieldValue.ToString();
            }

            //Create target expression
            if (!string.IsNullOrEmpty(languageRequest.TargetText))
            {
                var targetExpr       = EscapeCharacters(languageRequest.TargetText, caseSensitive, useWildCards);
                var targetFieldValue = new ExpressionFieldValue
                {
                    Name     = "trg",
                    Operator = "~",
                    Value    = targetExpr
                };
                targetFieldExpression = targetFieldValue.ToString();
            }

            // combine expressions if we have both source and target
            if (sourceFieldExpression != string.Empty && targetFieldExpression != string.Empty)
            {
                expression = sourceFieldExpression + "&" + targetFieldExpression;
            }
            else if (sourceFieldExpression != string.Empty)
            {
                expression = sourceFieldExpression;
            }
            else if (targetFieldExpression != string.Empty)
            {
                expression = targetFieldExpression;
            }

            return(expression);
        }
Beispiel #3
0
        public static RestFilterExpression GetRestFilterExpression(string expression, LanguageDetailsRequest langage)
        {
            var restFilterExpression = new RestFilterExpression();

            if (!string.IsNullOrEmpty(langage.SourceText) && !string.IsNullOrEmpty(langage.TargetText))
            {
                restFilterExpression.Expression = expression;
                restFilterExpression.Fields     = new List <RequestField>
                {
                    new RequestField
                    {
                        Name   = "src",
                        Type   = "SingleString",
                        Values = null
                    },
                    new RequestField
                    {
                        Name   = "trg",
                        Type   = "SingleString",
                        Values = null
                    }
                };
            }
            else if (!string.IsNullOrEmpty(langage.SourceText))
            {
                restFilterExpression.Expression = expression;
                restFilterExpression.Fields     = new List <RequestField>
                {
                    new RequestField
                    {
                        Name   = "src",
                        Type   = "SingleString",
                        Values = null
                    }
                };
            }
            else    //Create target expression
            if (!string.IsNullOrEmpty(langage.TargetText))
            {
                restFilterExpression.Expression = expression;
                restFilterExpression.Fields     = new List <RequestField>
                {
                    new RequestField
                    {
                        Name   = "trg",
                        Type   = "SingleString",
                        Values = null
                    }
                };
            }
            return(restFilterExpression);
        }