public static AlertEntity CreateAlert(Entity entity)
        {
            if(entity.IsNew)
                return null;

            return new AlertEntity { Target = entity.ToLite() };
        }
Example #2
0
        public static object Convert(object obj, Type type)
        {
            if (obj == null)
            {
                return(null);
            }

            Type objType = obj.GetType();

            if (type.IsAssignableFrom(objType))
            {
                return(obj);
            }

            if (objType.IsLite() && type.IsAssignableFrom(((Lite <IEntity>)obj).EntityType))
            {
                Lite <Entity> lite = (Lite <Entity>)obj;
                return(lite.UntypedEntityOrNull ?? RetrieveAndForget(lite));
            }

            if (type.IsLite())
            {
                Type liteType = Lite.Extract(type);

                if (liteType.IsAssignableFrom(objType))
                {
                    Entity ident = (Entity)obj;
                    return(ident.ToLite(ident.IsNew));
                }
            }

            throw new InvalidCastException("Impossible to convert objet {0} from type {1} to type {2}".FormatWith(obj, objType, type));
        }
Example #3
0
 public static PrintLineEntity CreateLine(Entity referred, FilePathEmbedded file)
 {
     return(new PrintLineEntity
     {
         Referred = referred.ToLite(),
         State = PrintLineState.ReadyToPrint,
         File = file,
     }.Save());
 }
Example #4
0
        public static AlertEntity CreateAlert(Entity entity)
        {
            if (entity.IsNew)
            {
                return(null);
            }

            return(new AlertEntity {
                Target = entity.ToLite()
            });
        }
        public static AlertEntity CreateAlert(Entity entity)
        {
            if(entity.IsNew)
                return null;

            return new AlertEntity
            {
                Target = entity.ToLite(),
                CreatedBy = UserHolder.Current?.ToLite()
            };
        }
        public static NoteEntity CreateNote(Entity entity)
        {
            if (entity.IsNew)
                return null;

            return new NoteEntity
            {
                Target = entity.ToLite(),
                CreationDate = Server.Return((IBaseServer s) => s.ServerNow()),
                CreatedBy = UserHolder.Current.ToLite(),
            };
        }
Example #7
0
        public static AlertEntity CreateAlert(Entity entity)
        {
            if (entity.IsNew)
            {
                return(null);
            }

            return(new AlertEntity
            {
                Target = entity.ToLite(),
                CreatedBy = UserHolder.Current?.ToLite()
            });
        }
Example #8
0
        public static NoteEntity CreateNote(Entity entity)
        {
            if (entity.IsNew)
            {
                return(null);
            }

            return(new NoteEntity
            {
                Target = entity.ToLite(),
                CreationDate = Server.Return((IBaseServer s) => s.ServerNow()),
                CreatedBy = UserHolder.Current.ToLite(),
            });
        }
Example #9
0
 private static FindOptions GetFindOptions(Entity ident, string property)
 {
     return(new FindOptions
     {
         QueryName = typeof(AlertEntity),
         Create = false,
         SearchOnLoad = true,
         ShowFilters = false,
         FilterOptions =
         {
             new FilterOption("Target",             ident.ToLite()),
             new FilterOption("Entity." + property, true),
         },
         ColumnOptions = { new ColumnOption("Target") },
         ColumnOptionsMode = ColumnOptionsMode.Remove,
     });
 }
Example #10
0
        private EmailMessageEntity CreateEmailMessageInternal(EmailFromEmbedded from, List <EmailOwnerRecipientData> recipients)
        {
            EmailMessageEntity email;

            try
            {
                var ci = this.cultureInfo ??
                         EmailTemplateLogic.GetCultureInfo?.Invoke(entity ?? model?.UntypedEntity as Entity) ??
                         recipients.Where(a => a.Kind == EmailRecipientKind.To).Select(a => a.OwnerData.CultureInfo).FirstOrDefault()?.ToCultureInfo() ??
                         EmailLogic.Configuration.DefaultCulture.ToCultureInfo();

                email = new EmailMessageEntity
                {
                    Target     = entity?.ToLite() ?? (this.model !.UntypedEntity as Entity)?.ToLite(),
                    Recipients = recipients.Select(r => new EmailRecipientEmbedded(r.OwnerData)
                    {
                        Kind = r.Kind
                    }).ToMList(),
                    From            = from,
                    IsBodyHtml      = template.IsBodyHtml,
                    EditableMessage = template.EditableMessage,
                    Template        = template.ToLite(),
                    Attachments     = template.Attachments.SelectMany(g => EmailTemplateLogic.GenerateAttachment.Invoke(g,
                                                                                                                        new EmailTemplateLogic.GenerateAttachmentContext(this.qd, template, dicTokenColumn, currentRows, ci)
                    {
                        ModelType = template.Model?.ToType(),
                        Model     = model,
                        Entity    = entity,
                    })).ToMList()
                };

                EmailTemplateMessageEmbedded?message =
                    template.GetCultureMessage(ci) ??
                    template.GetCultureMessage(ci.Parent) ??
                    template.GetCultureMessage(EmailLogic.Configuration.DefaultCulture.ToCultureInfo()) ??
                    template.GetCultureMessage(EmailLogic.Configuration.DefaultCulture.ToCultureInfo().Parent);

                if (message == null)
                {
                    throw new InvalidOperationException("Message {0} does not have a message for CultureInfo {1} (or Default)".FormatWith(template, ci));
                }

                using (CultureInfoUtils.ChangeBothCultures(ci))
                {
                    email.Subject = SubjectNode(message).Print(
                        new TextTemplateParameters(entity, ci, dicTokenColumn, currentRows)
                    {
                        IsHtml = false,
                        Model  = model
                    });

                    email.Body = new BigStringEmbedded(TextNode(message).Print(
                                                           new TextTemplateParameters(entity, ci, dicTokenColumn, currentRows)
                    {
                        IsHtml = template.IsBodyHtml,
                        Model  = model,
                    }));
                }
            }
            catch (Exception ex)
            {
                ex.Data["Template"] = this.template.ToLite();
                ex.Data["Model"]    = this.model;
                ex.Data["Entity"]   = this.entity;
                throw;
            }

            return(email);
        }
Example #11
0
        static void OperationExecute(IEntityOperationContext eoc)
        {
            if (eoc.CanExecute != null)
            {
                throw new ApplicationException("Operation {0} is disabled: {1}".FormatWith(eoc.OperationInfo.OperationSymbol, eoc.CanExecute));
            }

            if (eoc.OperationSettings != null && eoc.OperationSettings.HasClick)
            {
                IEntity newIdent = eoc.OperationSettings.OnClick(eoc);
                if (newIdent != null)
                {
                    eoc.EntityControl.RaiseEvent(new ChangeDataContextEventArgs(newIdent));
                }
            }
            else
            {
                Entity ident = (Entity)(IEntity)eoc.Entity;
                if (eoc.OperationInfo.OperationType == OperationType.Execute)
                {
                    if (eoc.OperationInfo.Lite.Value)
                    {
                        if (eoc.EntityControl.LooseChangesIfAny())
                        {
                            if (eoc.ConfirmMessage())
                            {
                                Lite <Entity> lite     = ident.ToLite();
                                IEntity       newIdent = Server.Return((IOperationServer s) => s.ExecuteOperationLite(lite, eoc.OperationInfo.OperationSymbol, null));
                                if (eoc.OperationInfo.Returns)
                                {
                                    eoc.EntityControl.RaiseEvent(new ChangeDataContextEventArgs(newIdent));
                                }
                            }
                        }
                    }
                    else
                    {
                        if (eoc.ConfirmMessage())
                        {
                            try
                            {
                                IEntity newIdent = Server.Return((IOperationServer s) => s.ExecuteOperation(ident, eoc.OperationInfo.OperationSymbol, null));
                                if (eoc.OperationInfo.Returns)
                                {
                                    eoc.EntityControl.RaiseEvent(new ChangeDataContextEventArgs(newIdent));
                                }
                            }
                            catch (IntegrityCheckException e)
                            {
                                GraphExplorer.SetValidationErrors(GraphExplorer.FromRoot(ident), e);
                                throw e;
                            }
                        }
                    }
                }
                else if (eoc.OperationInfo.OperationType == OperationType.ConstructorFrom)
                {
                    if (eoc.OperationInfo.Lite.Value && !eoc.EntityControl.LooseChangesIfAny())
                    {
                        return;
                    }

                    if (!eoc.ConfirmMessage())
                    {
                        return;
                    }

                    IEntity result = (Entity) new ConstructorContext(eoc.EntityControl, eoc.OperationInfo).SurroundConstructUntyped(eoc.OperationInfo.ReturnType, ctx =>
                    {
                        Entity r;

                        if (eoc.OperationInfo.Lite.Value)
                        {
                            r = Server.Return((IOperationServer s) => s.ConstructFromLite(ident.ToLite(), eoc.OperationInfo.OperationSymbol, null));
                        }
                        else
                        {
                            try
                            {
                                r = Server.Return((IOperationServer s) => s.ConstructFrom(ident, eoc.OperationInfo.OperationSymbol, null));
                            }
                            catch (IntegrityCheckException e)
                            {
                                GraphExplorer.SetValidationErrors(GraphExplorer.FromRoot(ident), e);
                                throw e;
                            }
                        }

                        if (r == null)
                        {
                            MessageBox.Show(Window.GetWindow(eoc.EntityControl), OperationMessage.TheOperation0DidNotReturnAnEntity.NiceToString().FormatWith(eoc.OperationInfo.OperationSymbol.NiceToString()));
                        }

                        return(r);
                    });

                    if (result != null)
                    {
                        Navigator.Navigate(result);
                    }
                }
                else if (eoc.OperationInfo.OperationType == OperationType.Delete)
                {
                    if (eoc.ConfirmMessage())
                    {
                        Lite <Entity> lite = ident.ToLite();
                        Server.Execute((IOperationServer s) => s.DeleteLite(lite, eoc.OperationInfo.OperationSymbol, null));
                        Window.GetWindow(eoc.EntityControl).Close();
                    }
                }
            }
        }
Example #12
0
        public virtual List <Filter> GetFilters(QueryDescription qd)
        {
            var imp = qd.Columns.SingleEx(a => a.IsEntity).Implementations.Value;

            if (imp.IsByAll && typeof(Entity).IsAssignableFrom(typeof(T)) || imp.Types.Contains(typeof(T)))
            {
                return new List <Filter>
                       {
                           new FilterCondition(QueryUtils.Parse("Entity", qd, 0), FilterOperation.EqualTo, Entity.ToLite())
                       }
            }
            ;

            throw new InvalidOperationException($"Since {typeof(T).Name} is not in {imp}, it's necessary to override ${nameof(GetFilters)} in ${this.GetType().Name}");
        }
Example #13
0
 private static IDisposable?ExecutionMode_OnApiRetrieved(Entity entity, string url)
 {
     return(ViewLogLogic.LogView(entity.ToLite(), url));
 }
 private static FindOptions GetFindOptions(Entity ident, string property)
 {
     return new FindOptions
     {
         QueryName = typeof(AlertEntity),
         Create = false,
         SearchOnLoad = true,
         ShowFilters = false,
         FilterOptions = 
         { 
             new FilterOption("Target", ident.ToLite()),
             new FilterOption("Entity." + property, true),
         },
         ColumnOptions = { new ColumnOption("Target") },
         ColumnOptionsMode = ColumnOptionsMode.Remove,
     };
 }
Example #15
0
        public static bool IsAllowedFor(this Entity entity, TypeAllowedBasic requested)
        {
            TypeAllowedAndConditions tac = GetAllowed(entity.GetType());

            if (requested <= tac.MinUI())
            {
                return(true);
            }

            if (tac.MaxUI() < requested)
            {
                return(false);
            }

            return(Server.Return((ITypeAuthServer s) => s.IsAllowedForInUserInterface(entity.ToLite(), requested)));
        }
Example #16
0
        public virtual object View(object entityOrLite, ViewOptions options)
        {
            if (entityOrLite == null)
            {
                throw new ArgumentNullException("entity");
            }

            ModifiableEntity entity   = entityOrLite as ModifiableEntity;
            Type             liteType = null;

            if (entity == null)
            {
                liteType = Lite.Extract(entityOrLite.GetType());
                entity   = Server.Retrieve((Lite <Entity>)entityOrLite);
            }

            EntitySettings es = AssertViewableEntitySettings(entity);

            if (!es.OnIsViewable())
            {
                throw new Exception("{0} is not viewable".FormatWith(entity));
            }

            Control ctrl = options.View ?? es.CreateView(entity, options.PropertyRoute);

            ctrl = es.OnOverrideView(entity, ctrl);

            NormalWindow win = CreateNormalWindow();

            SetNormalWindowEntity(win, (ModifiableEntity)entity, options, es, ctrl);

            if (options.AllowErrors != AllowErrors.Ask)
            {
                win.AllowErrors = options.AllowErrors;
            }

            bool?ok = win.ShowDialog();

            if (ok != true)
            {
                return(null);
            }

            object result = win.DataContext;

            if (liteType != null)
            {
                Entity ident = (Entity)result;

                bool saveProtected = ((ViewOptions)options).RequiresSaveOperation ?? EntityKindCache.RequiresSaveOperation(ident.GetType());

                if (GraphExplorer.HasChanges(ident))
                {
                    if (saveProtected)
                    {
                        throw new InvalidOperationException("The lite '{0}' of type '{1}' is SaveProtected but has changes. Consider setting SaveProtected = false in ViewOptions".FormatWith(entityOrLite, liteType.TypeName()));
                    }

                    return(ident.ToLiteFat());
                }

                return(ident.ToLite());
            }
            return(result);
        }
Example #17
0
        public IEnumerable <EmailMessageEntity> CreateEmailMessageInternal()
        {
            ExecuteQuery();

            foreach (EmailAddressEmbedded from in GetFrom())
            {
                foreach (List <EmailOwnerRecipientData> recipients in GetRecipients())
                {
                    CultureInfo ci = recipients.Where(a => a.Kind == EmailRecipientKind.To).Select(a => a.OwnerData.CultureInfo).FirstOrDefault()?.ToCultureInfo() ??
                                     EmailLogic.Configuration.DefaultCulture.ToCultureInfo();

                    EmailMessageEntity email = new EmailMessageEntity
                    {
                        Target     = entity?.ToLite() ?? (this.model !.UntypedEntity as Entity)?.ToLite(),
                        Recipients = recipients.Select(r => new EmailRecipientEmbedded(r.OwnerData)
                        {
                            Kind = r.Kind
                        }).ToMList(),
                        From            = from,
                        IsBodyHtml      = template.IsBodyHtml,
                        EditableMessage = template.EditableMessage,
                        Template        = template.ToLite(),
                        Attachments     = template.Attachments.SelectMany(g => EmailTemplateLogic.GenerateAttachment.Invoke(g,
                                                                                                                            new EmailTemplateLogic.GenerateAttachmentContext(this.qd, template, dicTokenColumn, currentRows, ci)
                        {
                            ModelType = template.Model?.ToType(),
                            Model     = model,
                            Entity    = entity,
                        })).ToMList()
                    };

                    EmailTemplateMessageEmbedded message = template.GetCultureMessage(ci) ?? template.GetCultureMessage(EmailLogic.Configuration.DefaultCulture.ToCultureInfo());

                    if (message == null)
                    {
                        throw new InvalidOperationException("Message {0} does not have a message for CultureInfo {1} (or Default)".FormatWith(template, ci));
                    }

                    using (CultureInfoUtils.ChangeBothCultures(ci))
                    {
                        email.Subject = SubjectNode(message).Print(
                            new TextTemplateParameters(entity, ci, dicTokenColumn, currentRows)
                        {
                            IsHtml = false,
                            Model  = model
                        });

                        email.Body = TextNode(message).Print(
                            new TextTemplateParameters(entity, ci, dicTokenColumn, currentRows)
                        {
                            IsHtml = template.IsBodyHtml,
                            Model  = model,
                        });
                    }


                    yield return(email);
                }
            }
        }

        TextTemplateParser.BlockNode TextNode(EmailTemplateMessageEmbedded message)
        {
            if (message.TextParsedNode == null)
            {
                string body = message.Text;

                if (template.MasterTemplate != null)
                {
                    var emt  = template.MasterTemplate.RetrieveAndRemember();
                    var emtm = emt.GetCultureMessage(message.CultureInfo.ToCultureInfo()) ??
                               emt.GetCultureMessage(EmailLogic.Configuration.DefaultCulture.ToCultureInfo());

                    if (emtm != null)
                    {
                        body = EmailMasterTemplateEntity.MasterTemplateContentRegex.Replace(emtm.Text, m => body);
                    }
                }

                message.TextParsedNode = TextTemplateParser.Parse(body, qd, template.Model?.ToType());
            }

            return((TextTemplateParser.BlockNode)message.TextParsedNode);
        }

        TextTemplateParser.BlockNode SubjectNode(EmailTemplateMessageEmbedded message)
        {
            if (message.SubjectParsedNode == null)
            {
                message.SubjectParsedNode = TextTemplateParser.Parse(message.Subject, qd, template.Model?.ToType());
            }

            return((TextTemplateParser.BlockNode)message.SubjectParsedNode);
        }

        IEnumerable <EmailAddressEmbedded> GetFrom()
        {
            if (template.From != null)
            {
                if (template.From.Token != null)
                {
                    ResultColumn owner = dicTokenColumn.GetOrThrow(template.From.Token.Token);

                    if (!template.SendDifferentMessages)
                    {
                        yield return(new EmailAddressEmbedded(currentRows.Select(r => (EmailOwnerData)r[owner] !).Distinct().SingleEx()));
                    }
                    else
                    {
                        var groups = currentRows.GroupBy(r => (EmailOwnerData)r[owner] !);

                        if (groups.Count() == 1 && groups.Single().Key?.Owner == null)
                        {
                            yield break;
                        }
                        else
                        {
                            foreach (var gr in groups)
                            {
                                var old = currentRows;
                                currentRows = gr;

                                yield return(new EmailAddressEmbedded(gr.Key));

                                currentRows = old;
                            }
                        }
                    }
                }
                else
                {
                    yield return(new EmailAddressEmbedded(new EmailOwnerData
                    {
                        CultureInfo = null,
                        Email = template.From.EmailAddress !,
                        DisplayName = template.From.DisplayName,
                    }));
        public IEnumerable <EmailMessageEntity> CreateEmailMessageInternal()
        {
            ExecuteQuery();

            foreach (EmailAddressEmbedded from in GetFrom())
            {
                foreach (List <EmailOwnerRecipientData> recipients in GetRecipients())
                {
                    CultureInfo ci = recipients.Where(a => a.Kind == EmailRecipientKind.To).Select(a => a.OwnerData.CultureInfo).FirstOrDefault().ToCultureInfo() ?? EmailLogic.Configuration.DefaultCulture.ToCultureInfo();

                    EmailMessageEntity email = new EmailMessageEntity
                    {
                        Target     = entity?.ToLite() ?? (this.systemEmail.UntypedEntity as Entity)?.ToLite(),
                        Recipients = recipients.Select(r => new EmailRecipientEntity(r.OwnerData)
                        {
                            Kind = r.Kind
                        }).ToMList(),
                        From            = from,
                        IsBodyHtml      = template.IsBodyHtml,
                        EditableMessage = template.EditableMessage,
                        Template        = template.ToLite(),
                        Attachments     = template.Attachments.SelectMany(g => EmailTemplateLogic.GenerateAttachment.Invoke(g, new EmailTemplateLogic.GenerateAttachmentContext
                        {
                            QueryDescription = this.qd,
                            ModelType        = template.SystemEmail.ToType(),
                            SystemEmail      = systemEmail,
                            CurrentRows      = currentRows,
                            ResultColumns    = dicTokenColumn,
                            Entity           = entity,
                            Template         = template,
                            Culture          = ci,
                        })).ToMList()
                    };

                    EmailTemplateMessageEmbedded message = template.GetCultureMessage(ci) ?? template.GetCultureMessage(EmailLogic.Configuration.DefaultCulture.ToCultureInfo());

                    if (message == null)
                    {
                        throw new InvalidOperationException("Message {0} does not have a message for CultureInfo {1} (or Default)".FormatWith(template, ci));
                    }

                    using (CultureInfoUtils.ChangeBothCultures(ci))
                    {
                        email.Subject = SubjectNode(message).Print(
                            new EmailTemplateParameters(entity, ci, dicTokenColumn, currentRows)
                        {
                            IsHtml      = false,
                            SystemEmail = systemEmail
                        });

                        email.Body = TextNode(message).Print(
                            new EmailTemplateParameters(entity, ci, dicTokenColumn, currentRows)
                        {
                            IsHtml      = template.IsBodyHtml,
                            SystemEmail = systemEmail,
                        });
                    }


                    yield return(email);
                }
            }
        }
        void ExecuteQuery()
        {
            using (ExecutionMode.Global())
            {
                List <QueryToken> tokens = new List <QueryToken>();
                if (template.From != null && template.From.Token != null)
                {
                    tokens.Add(template.From.Token.Token);
                }

                foreach (var tr in template.Recipients.Where(r => r.Token != null))
                {
                    tokens.Add(tr.Token.Token);
                }

                foreach (var t in template.Messages)
                {
                    TextNode(t).FillQueryTokens(tokens);
                    SubjectNode(t).FillQueryTokens(tokens);
                }

                foreach (var a in template.Attachments)
                {
                    EmailTemplateLogic.FillAttachmentTokens.Invoke(a, new EmailTemplateLogic.FillAttachmentTokenContext
                    {
                        QueryDescription = qd,
                        ModelType        = template.SystemEmail.ToType(),
                        QueryTokens      = tokens,
                    });
                }

                var columns = tokens.Distinct().Select(qt => new Column(qt, null)).ToList();

                var filters = systemEmail != null?systemEmail.GetFilters(qd) :
                                  new List <Filter>
                {
                    new Filter(QueryUtils.Parse("Entity", qd, 0), FilterOperation.EqualTo, entity.ToLite())
                };

                this.table = DynamicQueryManager.Current.ExecuteQuery(new QueryRequest
                {
                    QueryName  = queryName,
                    Columns    = columns,
                    Pagination = systemEmail?.GetPagination() ?? new Pagination.All(),
                    Filters    = filters,
                    Orders     = systemEmail?.GetOrders(qd) ?? new List <Order>(),
                });

                this.dicTokenColumn = table.Columns.ToDictionary(rc => rc.Column.Token);

                this.currentRows = table.Rows;
            }
        }
Example #20
0
 private static Entity RetrieveFresh(Entity entity)
 {
     using (new EntityCache(EntityCacheType.ForceNew))
         return(entity.ToLite().RetrieveAndRemember());
 }
Example #21
0
        public static SMSMessageEntity CreateSMSMessage(Lite <SMSTemplateEntity> template, Entity entity, ISMSModel?model, CultureInfo?forceCulture)
        {
            var t = SMSLogic.SMSTemplatesLazy.Value.GetOrThrow(template);

            var defaultCulture = SMSLogic.Configuration.DefaultCulture.ToCultureInfo();

            var qd = QueryLogic.Queries.QueryDescription(t.Query.ToQueryName());

            List <QueryToken> tokens = new List <QueryToken>();

            t.ParseData(qd);

            tokens.Add(t.To.Token);
            var parsedNodes = t.Messages.ToDictionary(
                tm => tm.CultureInfo.ToCultureInfo(),
                tm => TextTemplateParser.Parse(tm.Message, qd, t.Model?.ToType())
                );

            parsedNodes.Values.ToList().ForEach(n => n.FillQueryTokens(tokens));

            var columns = tokens.Distinct().Select(qt => new Column(qt, null)).ToList();

            var filters = model != null?model.GetFilters(qd) :
                              new List <Filter>
            {
                new FilterCondition(QueryUtils.Parse("Entity", qd, 0), FilterOperation.EqualTo, entity.ToLite())
            };


            var table = QueryLogic.Queries.ExecuteQuery(new QueryRequest
            {
                QueryName  = qd.QueryName,
                Columns    = columns,
                Pagination = model?.GetPagination() ?? new Pagination.All(),
                Filters    = filters,
                Orders     = model?.GetOrders(qd) ?? new List <Order>(),
            });

            var columnTokens = table.Columns.ToDictionary(a => a.Column.Token);

            var ownerData = (SMSOwnerData)table.Rows[0][columnTokens.GetOrThrow(t.To.Token)] !;

            var ci = forceCulture ?? ownerData.CultureInfo?.ToCultureInfo() ?? defaultCulture;

            var node = parsedNodes.TryGetC(ci) ?? parsedNodes.GetOrThrow(defaultCulture);

            return(new SMSMessageEntity
            {
                Template = t.ToLite(),
                Message = node.Print(new TextTemplateParameters(entity, ci, columnTokens, table.Rows)
                {
                    Model = model
                }),
                From = t.From,
                EditableMessage = t.EditableMessage,
                State = SMSMessageState.Created,
                Referred = ownerData.Owner,
                DestinationNumber = ownerData.TelephoneNumber,
                Certified = t.Certified
            });
        }