Esempio n. 1
0
        public override object Process(Entity en, object o)
        {
            Classification measureClass            = Universe.Classifications["MSR"];
            Variation      measureVariation        = Universe.Variations["Schade en inkomen"];
            StatusCode     measureOpenStatus       = measureClass.StatusCodes["MeasureOpenStatus"];
            StatusCode     measureProcessingStatus = measureClass.StatusCodes["MeasureProcessingStatus"];


            string eodToDay = DateTime.Today.AddDays(1).AddSeconds(-1).ToString("yyyy-mm-dd HH:mm:ss");

            using (Query q = new Query())
            {
                q.CommandText = @"SELECT DISTINCT e.Id as EntityId from Entities e WITH(NOLOCK)
                                    INNER JOIN Attributes a (NOLOCK) on e.Id = a.EntityID
                                    INNER JOIN AttributeTypes att (NOLOCK) on att.ID = a.TypeID
                                 WHERE 
                                    e.ClassID = @ClassID 
                                    AND e.VariationID = @VariationID 
                                    AND e.StatusId = @StatusID
                                    AND att.Reference = @EndDtAtt
                                    AND a.Value <= @CurrentDt";

                q.Parameter("@ClassID", measureClass.ID);
                q.Parameter("@VariationID", measureVariation.ID);
                q.Parameter("@StatusID", measureOpenStatus.ID);
                q.Parameter("@EndDtAtt", "enddt_ivr");
                q.Parameter("@CurrentDt", eodToDay);
                q.Select();

                while (!q.EOF)
                {
                    Entity entity = new Entity(q.GetGuid("id"));
                    entity.Status = measureProcessingStatus;
                    entity.SetAttribute("ivr", "False", true);
                    entity.Save();
                    entity.LoadLinks();

                    Fact f = new Fact();
                    f.Archetype = Universe.Classifications["registratiefeit"];
                    f.CaseID    = GetCaseEntity(entity).ID;
                    f.EntityID  = entity.ID;
                    f.Reference = entity.Reference;
                    f.Notes     = SerializaMeasure(entity);
                    f.Save();
                    Universe.Context.Notify(Universe.Translate("MEASURE.EXECUTE_SUCCES"));
                    entity.Status = measureOpenStatus;
                    entity.Save();

                    q.MoveNext();
                }

                return(o);
            }
        }
Esempio n. 2
0
        Entity CreateEmployee(Entity oldMgr, Relationship reportsTo)
        {
            var aaEmployee = CodeNameResolver.GetTypeByName("AA_Employee").As <EntityType>();

            var employee = new Entity(aaEmployee);

            employee.Save();
            var rel = employee.GetRelationships(reportsTo);

            rel.Add(oldMgr);
            employee.Save();
            ToDelete.Add(employee.Id);

            return(employee);
        }
Esempio n. 3
0
        public void RegexPatternChecksInvalid( )
        {
            StringField field = new StringField();

            field.Name       = "f1";
            field.IsRequired = true;
            field.Pattern    = Entity.Get <StringPattern>("emailPattern");
            field.IsRequired = false;

            EntityType type = new EntityType();

            type.Name = "t1";
            type.Fields.Add(field.As <Field>());
            type.Save();

            var e = new Entity(type.Id);

            try
            {
                e.SetField(field, "blah!!!");
                e.Save();
            }
            finally
            {
                e.Delete();
                field.Delete();
                type.Delete();
            }
        }
Esempio n. 4
0
        public void AutoNumberField_Seed()
        {
            var field = new AutoNumberField( );

            field.Name           = "TestAutoNumberField";
            field.AutoNumberSeed = 123;

            var definition = new Definition( );

            definition.Name = "TestAutoNumberDefinition";
            definition.Fields.Add(field.As <Field>( ));
            definition.Save( );

            Entity instance1 = new Entity(definition.Id);

            instance1.Save( );
            int value = instance1.GetField <int>(field);

            Assert.AreEqual(123, value);

            Entity instance2 = new Entity(definition.Id);

            instance2.Save( );
            value = instance2.GetField <int>(field);
            Assert.AreEqual(124, value);

            Entity instance3 = new Entity(definition.Id);

            instance3.Save( );
            value = instance3.GetField <int>(field);
            Assert.AreEqual(125, value);
        }
Esempio n. 5
0
        public void RegexDoesNotCheckEmptyStrings()
        {
            // Ensure that regex is not applied for empty string, if IsRequired is not set.

            StringField field = new StringField();

            field.Name       = "f1";
            field.IsRequired = true;
            field.Pattern    = Entity.Get <StringPattern>("emailPattern");
            field.IsRequired = false;

            EntityType type = new EntityType();

            type.Name = "t1";
            type.Fields.Add(field.As <Field>());
            type.Save();

            var e = new Entity(type.Id);

            e.SetField(field, "");
            e.Save( );

            e.Delete( );
            field.Delete();
            type.Delete();
        }
Esempio n. 6
0
        public override void OnSaved(object sender, EntityAfterEventArgs e)
        {
            base.OnSaved(sender, e);
            Entity entity = (Entity)sender;
            //UserConnection = entity.UserConnection;

            var    amountFC      = entity.GetTypedColumnValue <decimal>("AmountFC");
            var    date          = entity.GetTypedColumnValue <DateTime>("TransactionDate");
            var    currencyId    = entity.GetTypedColumnValue <Guid>("CurrencyId");
            string shortCurrency = entity.FindValueById <string>("Currency", currencyId, "ShortName");

            IBank       ibank  = BankFactory.GetBank(BankFactory.SupportedBanks.BOC);
            IBankResult result = null;

            Task.Run(async() =>
            {
                result = await ibank.GetRateAsync(shortCurrency, date);
            }).Wait();


            entity.SetColumnValue("FxRate", result.ExchangeRate);
            entity.SetColumnValue("AmountHC", amountFC * result.ExchangeRate);
            entity.Save();
            _log.Info($"rate:{result.ExchangeRate} on {result.RateDate:dd-MMM-yyyy}");
        }
        public void Entities()
        {
            ActiveRecordStarter.Initialize(GetConfigSource(),
                                           typeof(Entity), typeof(CompanyEntity), typeof(PersonEntity));
            Recreate();

            Entity.DeleteAll();
            CompanyEntity.DeleteAll();
            PersonEntity.DeleteAll();

            Entity ent = new Entity();

            ent.Name = "MS";
            ent.Save();

            CompanyEntity ce = new CompanyEntity();

            ce.Name        = "Keldor";
            ce.CompanyType = 1;
            ce.Save();

            Entity[] ents = Entity.FindAll();
            Assert.AreEqual(2, ents.Length);

            CompanyEntity[] ces = CompanyEntity.FindAll();
            Assert.AreEqual(1, ces.Length);

            PersonEntity[] pes = PersonEntity.FindAll();
            Assert.AreEqual(0, pes.Length);

            Assert.AreEqual(ce.CompId, ces[0].CompId);
            Assert.AreEqual(ce.Name, ces[0].Name);
            Assert.AreEqual(ce.Id, ces[0].Id);
        }
Esempio n. 8
0
        public virtual bool ScriptTask1Execute(ProcessExecutingContext context)
        {
            Guid CaseRecordId = default(Guid);

            if (StartSignal1.RecordId != Guid.Empty)
            {
                CaseRecordId = StartSignal1.RecordId;
            }
            if (StartSignal2.RecordId != Guid.Empty)
            {
                CaseRecordId = StartSignal2.RecordId;
            }
            var parameterReader = ClassFactory.Get <CaseCalculationParameterReader>(
                new ConstructorArgument("userConnection", UserConnection));
            var dictionaryParams            = parameterReader.GetParams(CaseRecordId);
            var caseTermCalculateEntryPoint = ClassFactory.Get <CaseTermCalculateEntryPoint>(
                new ConstructorArgument("userConnection", UserConnection));
            ServiceTermResponse response = caseTermCalculateEntryPoint.CalculateTerms(dictionaryParams, UserConnection.CurrentUser.GetCurrentDateTime());
            var    entitySchemaManager   = UserConnection.EntitySchemaManager;
            var    entitySchema          = entitySchemaManager.GetInstanceByName("Case");
            Entity entityCase            = entitySchema.CreateEntity(UserConnection);

            if (entityCase.FetchFromDB(CaseRecordId))
            {
                entityCase.SetColumnValue("SolutionDate", response.SolutionTime);
                entityCase.SetColumnValue("ResponseDate", response.ReactionTime);
                entityCase.Save();
            }
            return(true);
        }
        private void UpdateCampaign(SurveyCampaign campaign)
        {
            IEntityFieldValues fields;
            IDictionary <long, IChangeTracker <IMutableIdKey> > forwardRelationships;
            IDictionary <long, IChangeTracker <IMutableIdKey> > reverseRelationships;

            campaign.GetChanges(out fields, out forwardRelationships, out reverseRelationships);

            // handle a campaign having the due date updated.
            if (fields != null)
            {
                if (fields.ContainsField(SurveyCampaign.SurveyClosesOn_Field.Id))
                {
                    var tasks = new List <IEntity>();
                    foreach (var result in campaign.SurveyResponses)
                    {
                        foreach (var task in result.UserSurveyTaskForResults)
                        {
                            if (!(task.UserSurveyTaskForReview ?? false))
                            {
                                var writableTask = task.AsWritable <UserSurveyTask>();
                                writableTask.UserTaskDueOn = campaign.SurveyClosesOn;
                                tasks.Add(writableTask);
                            }
                        }
                    }

                    if (tasks.Any())
                    {
                        Entity.Save(tasks);
                    }
                }
            }
        }
        public override void OnSaving(object sender, EntityBeforeEventArgs e)
        {
            base.OnSaving(sender, e);
            Entity         entity         = (Entity)sender;
            UserConnection userConnection = entity.UserConnection;



            string oldValue = entity.GetTypedOldColumnValue <string>("Name");
            string newValue = entity.GetTypedColumnValue <string>("Name");

            if (!newValue.StartsWith("A"))
            {
                newValue = "A" + newValue;
                entity.SetColumnValue("Name", newValue);
                entity.Save();
                string msg = "Name did not start with an A, so I prefixed an A";


                //e.IsCanceled = true;
                //string msg = "Save canceled because name did not start with an A";
                _log.Info(msg);
            }


            string message = $"Changing name from {oldValue} to {newValue}";

            _log.Info(message);
        }
Esempio n. 11
0
 /// <summary>
 /// ######### ######### ##### #### # ## ##########.
 /// </summary>
 /// <param name="roleEntity">########, # ####### ##### ########## ######.</param>
 /// <param name="columnValues">######### ######## ####### #######.</param>
 /// <returns>############# ####.</returns>
 private object ChangeEntityAndSave(Entity roleEntity, Dictionary <string, object> columnValues)
 {
     UserConnection.DBSecurityEngine.CheckCanExecuteOperation("CanManageAdministration");
     columnValues.ForEach(kvp => SetRoleColumnValue(roleEntity, kvp));
     roleEntity.Save();
     return(roleEntity.GetColumnValue("Id"));
 }
Esempio n. 12
0
        private void toolStripButtonResolve_Click(object sender, EventArgs e)
        {
            entityFieldBindingSource.EndEdit();
            var NumUseYourChanges = conflicts.Where(c => c.UseYourChanges).Count();

            if (NumUseYourChanges == 0)
            {
                Entity.Fields = DBEntity.Fields.Clone();
            }
            else if (NumUseYourChanges == changes.Count())
            {
                Entity.Save(null);
            }
            else
            {
                foreach (var change in changes)
                {
                    if (!change.UseYourChanges)
                    {
                        Entity.Fields[Entity.Fields.IndexOf(change.LocalField)] = change.DBField.Clone() as EntityField;
                    }
                }
                Entity.Save(null);
            }
            DialogResult = DialogResult.OK;
        }
        public void TestDeleteRelated_WhenCircularDelete_ShouldResolve()
        {
            //---------------Set up test pack-------------------
            DataStoreInMemory dataStore = new DataStoreInMemory();

            BORegistry.DataAccessor = new DataAccessorInMemory(dataStore);
            Entity.LoadDefaultClassDef_WithCircularDeleteRelatedToSelf();
            Entity entity1 = new Entity();
            Entity entity2 = new Entity();

            entity1.Relationships.SetRelatedObject("RelatedEntity", entity2);
            entity2.Relationships.SetRelatedObject("RelatedEntity", entity1);
            entity1.Save();
            entity2.Save();
            entity1.MarkForDelete();
            TransactionCommitterInMemory committer = new TransactionCommitterInMemory(dataStore);

            committer.AddBusinessObject(entity1);
            //---------------Execute Test ----------------------
            committer.CommitTransaction();
            //---------------Test Result -----------------------
            AssertBOStateIsValidAfterDelete(entity1);
            AssertBOStateIsValidAfterDelete(entity2);

            AssertBusinessObjectNotInDataStore(entity1);
            AssertBusinessObjectNotInDataStore(entity2);
        }
        public void UpdateRel()
        {
            var employeeType = Entity.Get <EntityType>("test:employee");
            var managerType  = Entity.Get <EntityType>("test:manager");
            var reportsToRel = Entity.Get <Relationship>("test:reportsTo");

            var bob        = new Entity(employeeType);
            var bobManager = new Entity(employeeType);

            bob.Save();
            bobManager.Save();
            ToDelete.Add(bob.Id);
            ToDelete.Add(bobManager.Id);

            var updateActivity = new UpdateFieldActivity();

            updateActivity.InputArguments.Add(new ResourceArgument {
                Name = "1"
            }.Cast <ActivityArgument>());
            updateActivity.InputArguments.Add(new ResourceArgument {
                Name = "1_value_"
            }.Cast <ActivityArgument>());
            updateActivity.InputArguments.Add(new BoolArgument {
                Name = "1_reverse"
            }.Cast <ActivityArgument>());
            updateActivity.InputArguments.Add(new BoolArgument {
                Name = "1_replace"
            }.Cast <ActivityArgument>());

            updateActivity.Save();
            ToDelete.Add(updateActivity.Id);

            var updateActionAs = updateActivity.As <WfActivity>();

            ActivityImplementationBase nextActivity = updateActionAs.CreateWindowsActivity();

            var args = new Dictionary <string, object>
            {
                {
                    "Record", bob
                },
                {
                    "1_value_", bobManager
                },
                {
                    "1", reportsToRel
                },
                {
                    "1_reverse", false
                }
            };

            RunActivity(nextActivity, args);

            var bob2      = Entity.Get(bob);
            var reportsTo = bob2.GetRelationships(reportsToRel);

            Assert.AreEqual(1, reportsTo.Count(), "Relationship set");
            Assert.AreEqual(bobManager.Id, reportsTo.First().Entity.Id, "Manager is correct");
        }
        /// <summary>
        /// Sets email relations.
        /// </summary>
        /// <param name="userConnection">User Connection.</param>
        /// <param name="activity">Email activity.</param>
        public static void SetEmailRelations(UserConnection userConnection, Entity activity)
        {
            var autoEmailRelation = new AutoEmailRelation.AutoEmailRelation(userConnection);

            autoEmailRelation.ProceedRelation(activity);
            activity.Save(false);
        }
Esempio n. 16
0
        /// <summary>
        /// ######### ###### ################# # ##### "############" #, ####
        /// ### ##### ############, ######### ### # ######### ####.
        /// </summary>
        /// <param name="roleId">####, # ####### ##### ######## ##### ############.</param>
        protected void SaveUser(object roleId)
        {
            bool   isNew = false;
            object primaryColumnValue;

            changedValues.TryGetValue("Id", out primaryColumnValue);
            EntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByName("VwSysAdminUnit");
            Entity       entity       = entitySchema.CreateEntity(UserConnection);

            isNew = !entity.FetchFromDB(primaryColumnValue);
            if (isNew)
            {
                entity.SetDefColumnValues();
            }
            foreach (KeyValuePair <string, object> item in changedValues)
            {
                EntitySchemaColumn column      = entitySchema.Columns.GetByName(item.Key);
                object             columnValue = item.Value;
                if ((column.DataValueType is DateTimeDataValueType) && (item.Value != null))
                {
                    columnValue = DataTypeUtilities.ValueAsType <DateTime>(item.Value);
                }
                entity.SetColumnValue(column.ColumnValueName, columnValue);
            }
            entity.Save();
            if (isNew)
            {
                AddUserInRole(entity.PrimaryColumnValue, roleId);
            }
        }
Esempio n. 17
0
        private void CreateEntityModel(string idpUserName, bool active, out OidcIdentityProvider idProvider, out OidcIdentityProviderUser idProviderUser, out UserAccount userAccount)
        {
            var entitiesToSave = new List <IEntity>();

            // Setup provider, provider user and user account
            idProvider = new OidcIdentityProvider
            {
                Name = "ID Provider " + Guid.NewGuid(),
                IsProviderEnabled = true,
                OidcClientId      = "5E9762FD-8EB8-4626-AB5A-A52A05041DC0",
                OidcClientSecret  = "cZ7xNZiBvPB41Clw0i0FnR4LRqfHvj2H3tBt6c8l",
                OidcIdentityProviderConfigurationUrl = "https://rndev20adfs.sp.local/adfs/.well-known/openid-configuration",
                OidcUserIdentityClaim = "upn"
            };
            entitiesToSave.Add(idProvider);

            userAccount = new UserAccount {
                Name = "Test User " + Guid.NewGuid(), AccountStatus_Enum = active ? UserAccountStatusEnum_Enumeration.Active : UserAccountStatusEnum_Enumeration.Disabled
            };
            entitiesToSave.Add(userAccount);

            idProviderUser = new OidcIdentityProviderUser
            {
                AssociatedUserAccount = userAccount,
                Name = idpUserName,
                IdentityProviderForUser = idProvider.As <IdentityProvider>()
            };
            entitiesToSave.Add(idProviderUser);

            Entity.Save(entitiesToSave);
        }
        private void CreateReminding(ImportParameters parameters)
        {
            Guid     contactId            = parameters.AuthorId;
            DateTime dateTime             = TimeZoneInfo.ConvertTimeFromUtc(new DateTimeProvider().UtcNow, parameters.AuthorTimeZone);
            uint     notImportedRowsCount = parameters.NotImportedRowsCount;
            string   description          = string.Format(CompleteRemindingDescriptionTemplate, parameters.ImportedRowsCount,
                                                          parameters.TotalRowsCount, parameters.FileName);

            if (notImportedRowsCount > 0)
            {
                description += string.Format(NotImportedRowsCountMessageTemplate, notImportedRowsCount);
            }
            string caption = string.Format("{0} {1}", CompleteRemindingSubject, description);
            ISchemaManagerItem <EntitySchema> importSessionItem =
                UserConnection.EntitySchemaManager.GetItemByName("ImportSession");
            ISchemaManagerItem <EntitySchema> sysProcessLogItem =
                UserConnection.EntitySchemaManager.GetItemByName("VwSysProcessLog");

            EntitySchema remindingSchema = UserConnection.EntitySchemaManager.GetInstanceByName("Reminding");
            Entity       reminding       = remindingSchema.CreateEntity(UserConnection);

            reminding.SetDefColumnValues();
            reminding.SetColumnValue("AuthorId", contactId);
            reminding.SetColumnValue("ContactId", contactId);
            reminding.SetColumnValue("SourceId", RemindingConsts.RemindingSourceAuthorId);
            reminding.SetColumnValue("RemindTime", dateTime);
            reminding.SetColumnValue("Description", description);
            reminding.SetColumnValue("SubjectId", parameters.ImportSessionId);
            reminding.SetColumnValue("SysEntitySchemaId", sysProcessLogItem.UId);
            reminding.SetColumnValue("SubjectCaption", caption);
            reminding.SetColumnValue("LoaderId", importSessionItem.UId);
            reminding.Save();
        }
        /// <summary>
        /// Saves the prediction values to entity.
        /// </summary>
        /// <typeparam name="T">The type of predicted values.</typeparam>
        /// <param name="schemaUId">The entity schema's identifier, which should be saved.</param>
        /// <param name="entityId">The entity identifier.</param>
        /// <param name="predictedValues">The predicted values of entity for the several models.</param>
        /// <param name="valueTransformer">
        /// Optional mapping function, that should be applied to predicted value before saving.
        /// </param>
        /// <returns>
        /// <c>true</c> if the entity was saved, otherwise - <c>false</c>.
        /// </returns>
        protected virtual bool SaveEntityPredictedValues <T>(Guid schemaUId, Guid entityId,
                                                             Dictionary <MLModelConfig, T> predictedValues, Func <T, object> valueTransformer)
        {
            if (predictedValues.IsNullOrEmpty())
            {
                return(false);
            }
            Entity entity = GetEntity(schemaUId, entityId);

            if (entity == null)
            {
                return(false);
            }
            foreach (KeyValuePair <MLModelConfig, T> prediction in predictedValues)
            {
                MLModelConfig      model  = prediction.Key;
                EntitySchemaColumn column = entity.FindEntityColumnValue(model.PredictedResultColumnName).Column;
                if (valueTransformer != null)
                {
                    object transformedPredictionValue = valueTransformer(prediction.Value);
                    entity.SetColumnValue(column, transformedPredictionValue);
                }
                else
                {
                    entity.SetColumnValue(column, prediction.Value);
                }
            }
            return(entity.Save());
        }
Esempio n. 20
0
        public void Save(Entity entity)
        {
            if (entity == null)
            {
                throw new ArgumentNullException("entity");
            }

            TransactionOptions options = new TransactionOptions()
            {
                IsolationLevel = IsolationLevel.ReadCommitted
            };

            using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
            {
                entity.Save();
                foreach (Property property in entity.Properties)
                {
                    Save(property);
                }
                foreach (Entity child in entity.NestedEntities)
                {
                    Save(child);
                }
                foreach (Table table in entity.Tables)
                {
                    Save(table);
                }
                scope.Complete();
            }
        }
Esempio n. 21
0
        /// <summary>
        /// Inserts days in calendar.
        /// </summary>
        /// <param name="calendarId">Calendar identifier.</param>
        /// <param name="weekTemplate">Days in calendar.</param>
        /// <returns>Success of operation.</returns>
        protected virtual bool InsertDaysInCalendar(Guid calendarId, IEnumerable <ICalendarDay> weekTemplate)
        {
            if (weekTemplate.IsNullOrEmpty())
            {
                return(true);
            }
            bool         result = false;
            EntitySchema schema = _userConnection.EntitySchemaManager.FindInstanceByName("DayInCalendar");

            foreach (ICalendarDay day in weekTemplate)
            {
                Guid   dayOfWeekId = GetDayOfWeekId(day.DayOfWeek);
                Entity entity      = schema.CreateEntity(_userConnection);
                entity.SetColumnValue("DayTypeId", day.DayTypeUId);
                entity.SetColumnValue("DayOfWeekId", dayOfWeekId);
                entity.SetColumnValue("CalendarId", calendarId);
                result = entity.Save(validateRequired: false);
                if (!result)
                {
                    return(false);
                }
                result = InsertWorkingTimeIntervals("DayInCalendarId", entity.PrimaryColumnValue, day.WorkingIntervals);
            }
            return(result);
        }
        public void GetValidRequestContextFromCache_UnmappedOidcUser()
        {
            var entitiesToSave = new List <IEntity>();

            // Setup provider, provider user and user account
            var provider = new OidcIdentityProvider {
                Name = "ID Provider " + Guid.NewGuid()
            };

            entitiesToSave.Add(provider);

            var userAccount = new UserAccount {
                Name = "Test User " + Guid.NewGuid(), AccountStatus_Enum = UserAccountStatusEnum_Enumeration.Active
            };

            entitiesToSave.Add(userAccount);

            // Provider user has no associated user account
            var providerUser = new OidcIdentityProviderUser
            {
                Name = "Provider User" + Guid.NewGuid(),
                IdentityProviderForUser = provider.As <IdentityProvider>()
            };

            entitiesToSave.Add(providerUser);

            Entity.Save(entitiesToSave);

            var cache = new IdentityProviderContextCache();
            var requestContextData = cache.GetRequestContextData(RequestContext.TenantId, provider.Id, providerUser.Name, true);

            Assert.IsNull(requestContextData, "Context data should be null");
        }
Esempio n. 23
0
        public void TestPurge()
        {
            AuditLogEntityModelSettings entityModelSettings = ConfigurationSettings.GetAuditLogConfigurationSection().EntityModelSettings;
            bool      isEnabled         = entityModelSettings.IsEnabled;
            const int createdLogEntries = 10;
            const int maximumLogEntries = 5;

            try
            {
                var auditLogEntries = new List <LogonAuditLogEntry>();
                // Create 10 audit log entries
                for (int i = 0; i < createdLogEntries; i++)
                {
                    auditLogEntries.Add(new LogonAuditLogEntry());
                }

                Entity.Save(auditLogEntries);

                Assert.GreaterOrEqual(GetCountEntityModelAuditLogEntries(), createdLogEntries, "The number of log entries is invalid");

                var auditLogSettings = Entity.Get <AuditLogSettings>("tenantAuditLogSettingsInstance", true);
                auditLogSettings.MaxAuditLogEntries = maximumLogEntries;
                auditLogSettings.Save();

                entityModelSettings.IsEnabled = true;
                var deleter = new AuditLogEntityModelDeleter();
                Assert.Greater(deleter.Purge(), 0, "The number of log entries purged is invalid");

                Assert.AreEqual(maximumLogEntries, GetCountEntityModelAuditLogEntries(), "The number of remaining log entries is invalid");
            }
            finally
            {
                entityModelSettings.IsEnabled = isEnabled;
            }
        }
        /// <summary>
        /// Saves the predictions and updates column value if prediction is highly significant.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <param name="results">The results.</param>
        /// <param name="targetColumnName">Name of the target column.</param>
        /// <param name="valueSelectorFunc">Function for select value from prediction list to be setted in target field.
        /// If <c>null</c> - high significance value will be selected.</param>
        protected virtual void SavePredictions(Entity entity, List <ClassificationResult> results,
                                               string targetColumnName,
                                               Func <IEnumerable <ClassificationResult>, ClassificationResult> valueSelectorFunc)
        {
            var connectionArg = new ConstructorArgument("userConnection", _userConnection);
            var saver         = ClassFactory.Get <MLPredictionSaver>(connectionArg);

            saver.SavePrediction(ModelId, ModelInstanceUId, entity.PrimaryColumnValue, results);
            ClassificationResult highSignificanceValue = null;

            if (valueSelectorFunc != null)
            {
                highSignificanceValue = valueSelectorFunc(results);
            }
            else
            {
                highSignificanceValue = results.FirstOrDefault(result => result.Significance == HighSignificance);
            }
            if (highSignificanceValue == null)
            {
                _log.InfoFormat("No significant value detected for '{0}' with record id '{1}'",
                                entity.Schema.Name, entity.PrimaryColumnValue);
                return;
            }
            _log.InfoFormat("Saving significant value '{2}' for '{0}' with record id '{1}'",
                            entity.Schema.Name, entity.PrimaryColumnValue, highSignificanceValue.Value);
            EntitySchemaColumn targetColumn = entity.Schema.GetSchemaColumnByPath(targetColumnName);

            entity.SetColumnValue(targetColumn.ColumnValueName, new Guid(highSignificanceValue.Value));
            entity.Save(false);
        }
        private void SaveEntityFile(Stream template, Guid reportId)
        {
            Entity entity = GetReportEntity(reportId);

            entity.SetStreamValue("File", template);
            entity.Save();
        }
        /// <summary>
        /// Remove parent element from current
        /// </summary>
        /// <param name="childId"></param>
        public void RemoveParent(Guid parentId)
        {
            Entity entity = GetEntity(parentId);

            entity.SetColumnValue(_parentColumnName, null);
            entity.Save();
        }
        private void InnerSaveCell(Cell cell)
        {
            Entity entity = GetEntity();
            Dictionary <string, object> conditions = new Dictionary <string, object> {
                { PeriodColumnName, cell.PeriodId },
                { ForecastColumnName, cell.ColumnId },
                { SheetColumnName, ForecastSheet.Id },
                { EntityColumnName, cell.EntityId }
            };

            if (!entity.FetchFromDB(conditions, false))
            {
                Guid rowId = GetRowId(entity.SchemaName, cell.EntityId, ForecastSheet.Id);
                if (!RightsHelper.GetCanEditSchemaRecordRight(ForecastRow, rowId))
                {
                    throw new SecurityException(string.Format(
                                                    new LocalizableString("Terrasoft.Core", "Entity.Exception.NoRightFor.Insert"),
                                                    entity.SchemaName));
                }
                entity.SetDefColumnValues();
                entity.SetColumnValue($"{PeriodColumnName}Id", cell.PeriodId);
                entity.SetColumnValue($"{ForecastColumnName}Id", cell.ColumnId);
                entity.SetColumnValue($"{SheetColumnName}Id", ForecastSheet.Id);
                entity.SetColumnValue($"{EntityColumnName}Id", cell.EntityId);
                entity.SetColumnValue($"{RowColumnName}Id", rowId);
            }
            entity.SetColumnValue(ValueColumnName, cell.Value);
            entity.Save();
        }
        /// <summary>
        /// Set parent element to current element
        /// </summary>
        /// <param name="childId"></param>
        /// <param name="parentId"></param>
        public void ChangeParent(Guid childId, Guid parentId)
        {
            Entity entity = GetEntity(childId);

            entity.SetColumnValue(_parentColumnName, parentId);
            entity.Save();
        }
        public virtual bool ChangeApprovalWithLocationException(string entityName, Guid id,
                                                                Dictionary <string, object> additionalColumnValues)
        {
            EntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByName(entityName);
            Entity       entity       = entitySchema.CreateEntity(UserConnection);

            if (!entity.FetchFromDB(id))
            {
                throw new VisaNotFoundException();
            }
            if (IsFinalStatus(entity))
            {
                throw new VisaFinalStatusException();
            }
            entity.SetColumnValue("SetDate", DateTime.UtcNow);
            entity.SetColumnValue("SetById", UserConnection.CurrentUser.ContactId);
            if (additionalColumnValues != null)
            {
                foreach (var item in additionalColumnValues)
                {
                    entity.SetColumnValue(item.Key, item.Value);
                }
            }
            if (!entity.Save())
            {
                throw new SaveVisaChangesException();
            }
            return(true);
        }
        public override void OnSaving(object sender, EntityBeforeEventArgs e)
        {
            //Calling CreateSOAPWebRequest method test123
            HttpWebRequest request = CreateSOAPWebRequest();

            string val = "";

            //Geting response from request
            using (WebResponse Serviceres = request.GetResponse())
            {
                using (StreamReader rd = new StreamReader(Serviceres.GetResponseStream()))
                {
                    //reading stream
                    var ServiceResult = rd.ReadToEnd();
                    //var myDetails = JsonConvert.DeserializeObject<MyDetail>(ServiceResult);
                    var myDetails = JObject.Parse(ServiceResult);
                    val = (string)myDetails["rates"]["AED"];
                }
            }
            base.OnSaving(sender, e);
            Entity entity = (Entity)sender;

            entity.SetColumnValue("UsrNotes1", $"Currency Value {val}");
            entity.Save();
        }
        public void TestDeleteRelated_WhenCircularDelete_ShouldResolve()
        {
            //---------------Set up test pack-------------------
            DataStoreInMemory dataStore = new DataStoreInMemory();
            BORegistry.DataAccessor = new DataAccessorInMemory(dataStore);
            Entity.LoadDefaultClassDef_WithCircularDeleteRelatedToSelf();
            Entity entity1 = new Entity();
            Entity entity2 = new Entity();
            entity1.Relationships.SetRelatedObject("RelatedEntity", entity2);
            entity2.Relationships.SetRelatedObject("RelatedEntity", entity1);
            entity1.Save();
            entity2.Save();
            entity1.MarkForDelete();
            TransactionCommitterInMemory committer = new TransactionCommitterInMemory(dataStore);
            committer.AddBusinessObject(entity1);
            //---------------Execute Test ----------------------
            committer.CommitTransaction();
            //---------------Test Result -----------------------
            AssertBOStateIsValidAfterDelete(entity1);
            AssertBOStateIsValidAfterDelete(entity2);

            AssertBusinessObjectNotInDataStore(entity1);
            AssertBusinessObjectNotInDataStore(entity2);
        }
 public void TestDeleteRelated_WhenCircularDelete_ShouldResolve()
 {
     //---------------Set up test pack-------------------
     Entity.LoadDefaultClassDef_WithCircularDeleteRelatedToSelf();
     Entity entity1 = new Entity();
     Entity entity2 = new Entity();
     entity1.Relationships.SetRelatedObject("RelatedEntity", entity2);
     entity2.Relationships.SetRelatedObject("RelatedEntity", entity1);
     entity1.Save();
     entity2.Save();
     entity1.MarkForDelete();
     TransactionCommitterDB committer = new TransactionCommitterDB(DatabaseConnection.CurrentConnection);
     committer.AddBusinessObject(entity1);
     //---------------Execute Test ----------------------
     committer.CommitTransaction();
     //---------------Test Result -----------------------
     BOTestUtils.AssertBOStateIsValidAfterDelete(entity1);
     BOTestUtils.AssertBOStateIsValidAfterDelete(entity2);
     AssertBusinessObjectNotInDatabase(entity1);
     AssertBusinessObjectNotInDatabase(entity2);
 }