public static void Start(SchemaBuilder sb) { if (sb.NotDefined(MethodInfo.GetCurrentMethod())) { sb.Include <OrderEntity>() .WithQuery(() => o => new { Entity = o, o.Id, o.State, o.Customer, o.Employee, o.OrderDate, o.RequiredDate, o.ShipAddress, o.ShipVia, }); QueryLogic.Queries.Register(OrderQuery.OrderLines, () => from o in Database.Query <OrderEntity>() from od in o.Details select new { Entity = o, o.Id, od.Product, od.Quantity, od.UnitPrice, od.Discount, od.SubTotalPrice, }); OrderGraph.Register(); ProcessLogic.Register(OrderProcess.CancelOrders, new CancelOrderAlgorithm()); SimpleTaskLogic.Register(OrderTask.CancelOldOrdersWithProcess, ctx => { var package = new PackageEntity().CreateLines(Database.Query <OrderEntity>().Where(a => a.OrderDate < DateTime.Now.AddDays(-7) && a.State != OrderState.Canceled)); var process = ProcessLogic.Create(OrderProcess.CancelOrders, package); process.Execute(ProcessOperation.Execute); return(process.ToLite()); }); SimpleTaskLogic.Register(OrderTask.CancelOldOrders, ctx => { Database.Query <OrderEntity>() .Where(a => a.OrderDate < DateTime.Now.AddDays(-7)) .UnsafeUpdate() .Set(o => o.CancelationDate, o => DateTime.Now) .Set(o => o.State, o => OrderState.Canceled) .Execute(); return(null); });//CancelOldOrdersProcess } }
public static void Start(SchemaBuilder sb) { if (sb.NotDefined(MethodInfo.GetCurrentMethod())) { sb.Schema.Settings.AssertImplementedBy((ProcessEntity p) => p.Data, typeof(EmailPackageEntity)); sb.Include <EmailPackageEntity>() .WithQuery(() => e => new { Entity = e, e.Id, e.Name, }); QueryLogic.Expressions.Register((EmailPackageEntity ep) => ep.Messages(), () => EmailMessageMessage.Messages.NiceToString()); QueryLogic.Expressions.Register((EmailPackageEntity ep) => ep.RemainingMessages(), () => EmailMessageMessage.RemainingMessages.NiceToString()); QueryLogic.Expressions.Register((EmailPackageEntity ep) => ep.ExceptionMessages(), () => EmailMessageMessage.ExceptionMessages.NiceToString()); ProcessLogic.AssertStarted(sb); ProcessLogic.Register(EmailMessageProcess.CreateEmailsSendAsync, new CreateEmailsSendAsyncProcessAlgorithm()); ProcessLogic.Register(EmailMessageProcess.SendEmails, new SendEmailProcessAlgorithm()); new Graph <ProcessEntity> .ConstructFromMany <EmailMessageEntity>(EmailMessageOperation.ReSendEmails) { Construct = (messages, args) => { if (!messages.Any()) { return(null); } EmailPackageEntity emailPackage = new EmailPackageEntity() { Name = args.TryGetArgC <string>() }.Save(); foreach (var m in messages.Select(m => m.RetrieveAndForget())) { new EmailMessageEntity() { Package = emailPackage.ToLite(), From = m.From, Recipients = m.Recipients.ToMList(), Target = m.Target, Body = new BigStringEmbedded(m.Body.Text), IsBodyHtml = m.IsBodyHtml, Subject = m.Subject, Template = m.Template, EditableMessage = m.EditableMessage, State = EmailMessageState.RecruitedForSending, Attachments = m.Attachments.Select(a => a.Clone()).ToMList() }.Save(); } return(ProcessLogic.Create(EmailMessageProcess.SendEmails, emailPackage)); } } .Register(); } }
public static void Start(SchemaBuilder sb, FileTypeSymbol?testFileType = null) { if (sb.NotDefined(MethodInfo.GetCurrentMethod())) { TestFileType = testFileType; sb.Include <PrintLineEntity>() .WithQuery(() => p => new { Entity = p, p.CreationDate, p.File, p.State, p.Package, p.PrintedOn, p.Referred, }); sb.Include <PrintPackageEntity>() .WithQuery(() => e => new { Entity = e, e.Id, e.Name }); ProcessLogic.AssertStarted(sb); ProcessLogic.Register(PrintPackageProcess.PrintPackage, new PrintPackageAlgorithm()); PermissionAuthLogic.RegisterPermissions(PrintPermission.ViewPrintPanel); PrintLineGraph.Register(); SimpleTaskLogic.Register(PrintTask.RemoveOldFiles, (ScheduledTaskContext ctx) => { var lines = Database.Query <PrintLineEntity>().Where(a => a.State == PrintLineState.Printed).Where(b => b.CreationDate <= DateTime.Now.AddMinutes(-DeleteFilesAfter)); foreach (var line in lines) { try { using (Transaction tr = new Transaction()) { line.File.DeleteFileOnCommit(); line.State = PrintLineState.PrintedAndDeleted; using (OperationLogic.AllowSave <PackageLineEntity>()) line.Save(); tr.Commit(); } } catch (Exception e) { e.LogException(); } } return(null); }); } }
public static void Start(SchemaBuilder sb, Func <NewsletterEntity, EmailSenderConfigurationEntity> getEmailSenderConfiguration) { if (sb.NotDefined(MethodInfo.GetCurrentMethod())) { sb.Include <NewsletterEntity>(); sb.Include <NewsletterDeliveryEntity>(); NewsletterLogic.GetEmailSenderConfiguration = getEmailSenderConfiguration; ProcessLogic.AssertStarted(sb); ProcessLogic.Register(NewsletterProcess.SendNewsletter, new NewsletterProcessAlgorithm()); QueryLogic.Queries.Register(typeof(NewsletterEntity), () => from n in Database.Query <NewsletterEntity>() let p = n.LastProcess() select new { Entity = n, n.Id, n.Name, n.Subject, Text = n.Text.Try(a => a.Etc(100)), n.State, NumDeliveries = n.Deliveries().Count(), LastProcess = p, NumErrors = n.Deliveries().Count(d => d.Exception(p) != null) }); QueryLogic.Queries.Register(typeof(NewsletterDeliveryEntity), () => from e in Database.Query <NewsletterDeliveryEntity>() let p = e.Newsletter.Entity.LastProcess() select new { Entity = e, e.Id, e.Newsletter, e.Recipient, e.Sent, e.SendDate, LastProcess = p, Exception = e.Exception(p) }); NewsletterGraph.Register(); sb.AddUniqueIndex <NewsletterDeliveryEntity>(nd => new { nd.Newsletter, nd.Recipient }); Validator.PropertyValidator((NewsletterEntity news) => news.Text).StaticPropertyValidation += (sender, pi) => ValidateTokens(sender, sender.Text); Validator.PropertyValidator((NewsletterEntity news) => news.Subject).StaticPropertyValidation += (sender, pi) => ValidateTokens(sender, sender.Subject); sb.Schema.EntityEvents <NewsletterEntity>().PreSaving += Newsletter_PreSaving; } }
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm) { if (sb.NotDefined(MethodInfo.GetCurrentMethod())) { sb.Include <EmailPackageEntity>() .WithQuery(dqm, () => e => new { Entity = e, e.Id, e.Name, }); dqm.RegisterExpression((EmailPackageEntity ep) => ep.Messages(), () => EmailMessageMessage.Messages.NiceToString()); dqm.RegisterExpression((EmailPackageEntity ep) => ep.RemainingMessages(), () => EmailMessageMessage.RemainingMessages.NiceToString()); dqm.RegisterExpression((EmailPackageEntity ep) => ep.ExceptionMessages(), () => EmailMessageMessage.ExceptionMessages.NiceToString()); ProcessLogic.AssertStarted(sb); ProcessLogic.Register(EmailMessageProcess.CreateEmailsSendAsync, new CreateEmailsSendAsyncProcessAlgorithm()); ProcessLogic.Register(EmailMessageProcess.SendEmails, new SendEmailProcessAlgorithm()); new Graph <ProcessEntity> .ConstructFromMany <EmailMessageEntity>(EmailMessageOperation.ReSendEmails) { Construct = (messages, args) => { EmailPackageEntity emailPackage = new EmailPackageEntity() { Name = args.TryGetArgC <string>() }.Save(); foreach (var m in messages.Select(m => m.RetrieveAndForget())) { new EmailMessageEntity() { Package = emailPackage.ToLite(), From = m.From, Recipients = m.Recipients.ToMList(), Target = m.Target, Body = m.Body, IsBodyHtml = m.IsBodyHtml, Subject = m.Subject, Template = m.Template, EditableMessage = m.EditableMessage, State = EmailMessageState.RecruitedForSending }.Save(); } return(ProcessLogic.Create(EmailMessageProcess.SendEmails, emailPackage)); } } .Register(); } }
public static void Start(SchemaBuilder sb) { if (sb.NotDefined(MethodInfo.GetCurrentMethod())) { sb.Include <SMSSendPackageEntity>(); sb.Include <SMSUpdatePackageEntity>(); SMSLogic.AssertStarted(sb); ProcessLogic.AssertStarted(sb); ProcessLogic.Register(SMSMessageProcess.Send, new SMSMessageSendProcessAlgortihm()); ProcessLogic.Register(SMSMessageProcess.UpdateStatus, new SMSMessageUpdateStatusProcessAlgorithm()); SimpleTaskLogic.Register(SMSMessageTask.UpdateSMSStatus, ctx => UpdateAllSentSMS()?.ToLite()); new Graph <ProcessEntity> .ConstructFromMany <SMSMessageEntity>(SMSMessageOperation.CreateUpdateStatusPackage) { Construct = (messages, _) => UpdateMessages(messages.RetrieveFromListOfLite()) } .Register(); QueryLogic.Queries.Register(typeof(SMSSendPackageEntity), () => from e in Database.Query <SMSSendPackageEntity>() let p = e.LastProcess() select new { Entity = e, e.Id, e.Name, NumLines = e.SMSMessages().Count(), LastProcess = p, NumErrors = e.SMSMessages().Count(s => s.Exception(p) != null), }); QueryLogic.Queries.Register(typeof(SMSUpdatePackageEntity), () => from e in Database.Query <SMSUpdatePackageEntity>() let p = e.LastProcess() select new { Entity = e, e.Id, e.Name, NumLines = e.SMSMessages().Count(), LastProcess = p, NumErrors = e.SMSMessages().Count(s => s.Exception(p) != null), }); } }
public static void Start(SchemaBuilder sb, bool packages, bool packageOperations) { if (sb.NotDefined(MethodInfo.GetCurrentMethod())) { ProcessLogic.AssertStarted(sb); sb.Settings.AssertImplementedBy((ProcessExceptionLineEntity pel) => pel.Line, typeof(PackageLineEntity)); sb.Include <PackageLineEntity>() .WithQuery(() => pl => new { Entity = pl, pl.Package, pl.Id, pl.Target, pl.Result, pl.FinishTime, }); QueryLogic.Queries.Register(PackageQuery.PackageLineLastProcess, () => from pl in Database.Query <PackageLineEntity>() let p = pl.Package.Entity.LastProcess() select new { Entity = pl, pl.Package, pl.Id, pl.Target, pl.Result, pl.FinishTime, LastProcess = p, Exception = pl.Exception(p), }); QueryLogic.Expressions.Register((PackageEntity p) => p.Lines(), ProcessMessage.Lines); if (packages) { sb.Settings.AssertImplementedBy((PackageLineEntity pl) => pl.Package, typeof(PackageEntity)); sb.Settings.AssertImplementedBy((ProcessEntity pe) => pe.Data, typeof(PackageEntity)); sb.Include <PackageEntity>() .WithQuery(() => pk => new { Entity = pk, pk.Id, pk.Name, }); QueryLogic.Queries.Register(PackageQuery.PackageLastProcess, () => from pk in Database.Query <PackageEntity>() let pe = pk.LastProcess() select new { Entity = pk, pk.Id, pk.Name, NumLines = pk.Lines().Count(), LastProcess = pe, NumErrors = pk.Lines().Count(l => l.Exception(pe) != null), }); ExceptionLogic.DeleteLogs += ExceptionLogic_DeletePackages <PackageEntity>; } if (packageOperations) { sb.Settings.AssertImplementedBy((PackageLineEntity pl) => pl.Package, typeof(PackageOperationEntity)); sb.Settings.AssertImplementedBy((ProcessEntity pe) => pe.Data, typeof(PackageOperationEntity)); sb.Include <PackageOperationEntity>() .WithQuery(() => pk => new { Entity = pk, pk.Id, pk.Name, pk.Operation, }); QueryLogic.Queries.Register(PackageQuery.PackageOperationLastProcess, () => from p in Database.Query <PackageOperationEntity>() let pe = p.LastProcess() select new { Entity = p, p.Id, p.Name, p.Operation, NumLines = p.Lines().Count(), LastProcess = pe, NumErrors = p.Lines().Count(l => l.Exception(pe) != null), }); ProcessLogic.Register(PackageOperationProcess.PackageOperation, new PackageOperationAlgorithm()); ExceptionLogic.DeleteLogs += ExceptionLogic_DeletePackages <PackageOperationEntity>; } } }
public static void Start(SchemaBuilder sb, IFileTypeAlgorithm predictorFileAlgorithm) { if (sb.NotDefined(MethodInfo.GetCurrentMethod())) { sb.Settings.AssertIgnored((PredictorEntity p) => p.MainQuery.Filters.Single().Pinned, "use PredictorLogic", "by calling PredictorLogic.IgnorePinned in Starter.OverrideAttributes"); sb.Settings.AssertIgnored((PredictorSubQueryEntity p) => p.Filters.Single().Pinned, "use PredictorLogic", "by calling PredictorLogic.IgnorePinned in Starter.OverrideAttributes"); sb.Include <PredictorEntity>() .WithVirtualMList(p => p.SubQueries, mc => mc.Predictor) .WithQuery(() => e => new { Entity = e, e.Id, e.Name, e.MainQuery.Query, e.Algorithm, e.State, e.TrainingException, }); PredictorGraph.Register(); sb.Include <PredictorSubQueryEntity>() .WithQuery(() => e => new { Entity = e, e.Id, e.Name, e.Query, e.Predictor }); sb.Include <PredictorCodificationEntity>() .WithUniqueIndex(pc => new { pc.Predictor, pc.Index, pc.Usage }) .WithExpressionFrom((PredictorEntity e) => e.Codifications()) .WithQuery(() => e => new { Entity = e, e.Id, e.Predictor, e.Index, e.Usage, e.OriginalColumnIndex, e.SubQueryIndex, e.SplitKey0, e.SplitKey1, e.SplitKey2, e.IsValue, e.Min, e.Max, e.Average, e.StdDev, }); sb.Include <PredictorEpochProgressEntity>() .WithExpressionFrom((PredictorEntity e) => e.EpochProgresses()) .WithQuery(() => e => new { Entity = e, e.Predictor, e.Id, e.Epoch, e.Ellapsed, e.LossTraining, e.AccuracyTraining, e.LossValidation, e.AccuracyValidation, }); FileTypeLogic.Register(PredictorFileType.PredictorFile, predictorFileAlgorithm); SymbolLogic <PredictorAlgorithmSymbol> .Start(sb, () => Algorithms.Keys); SymbolLogic <PredictorColumnEncodingSymbol> .Start(sb, () => Algorithms.Values.SelectMany(a => a.GetRegisteredEncodingSymbols()).Distinct()); SymbolLogic <PredictorResultSaverSymbol> .Start(sb, () => ResultSavers.Keys); SymbolLogic <PredictorPublicationSymbol> .Start(sb, () => Publications.Keys); sb.Schema.EntityEvents <PredictorEntity>().Retrieved += PredictorEntity_Retrieved; sb.Schema.EntityEvents <PredictorSubQueryEntity>().Retrieved += PredictorMultiColumnEntity_Retrieved; Validator.PropertyValidator((PredictorColumnEmbedded c) => c.Encoding).StaticPropertyValidation += Column_StaticPropertyValidation; Validator.PropertyValidator((PredictorSubQueryColumnEmbedded c) => c.Token).StaticPropertyValidation += GroupKey_StaticPropertyValidation; Validator.PropertyValidator((PredictorSubQueryEntity c) => c.Columns).StaticPropertyValidation += SubQueryColumns_StaticPropertyValidation; sb.Include <PredictSimpleResultEntity>() .WithQuery(() => e => new { Entity = e, e.Id, e.Predictor, e.Target, e.Type, e.OriginalValue, e.PredictedValue, e.OriginalCategory, e.PredictedCategory, }); RegisterResultSaver(PredictorSimpleResultSaver.StatisticsOnly, new PredictorSimpleSaver { SaveAllResults = false }); RegisterResultSaver(PredictorSimpleResultSaver.Full, new PredictorSimpleSaver { SaveAllResults = true }); sb.Schema.EntityEvents <PredictorEntity>().PreUnsafeDelete += query => { Database.Query <PredictSimpleResultEntity>().Where(a => query.Contains(a.Predictor.Entity)).UnsafeDelete(); return(null); }; sb.Schema.WhenIncluded <ProcessEntity>(() => { sb.Schema.Settings.AssertImplementedBy((ProcessEntity p) => p.Data, typeof(PredictorEntity)); sb.Schema.Settings.AssertImplementedBy((ProcessEntity p) => p.Data, typeof(AutoconfigureNeuralNetworkEntity)); ProcessLogic.Register(PredictorProcessAlgorithm.AutoconfigureNeuralNetwork, new AutoconfigureNeuralNetworkAlgorithm()); new Graph <ProcessEntity> .ConstructFrom <PredictorEntity>(PredictorOperation.AutoconfigureNetwork) { CanConstruct = p => p.AlgorithmSettings is NeuralNetworkSettingsEntity ? null : ValidationMessage._0ShouldBeOfType1.NiceToString(p.NicePropertyName(_ => _.AlgorithmSettings), typeof(NeuralNetworkSettingsEntity).NiceName()), Construct = (p, _) => { return(ProcessLogic.Create(PredictorProcessAlgorithm.AutoconfigureNeuralNetwork, new AutoconfigureNeuralNetworkEntity { InitialPredictor = p.ToLite() })); } }.Register(); }); } }