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); } }
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); }
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(); } }
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); }
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(); }
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); }
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); }
/// <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")); }
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); }
/// <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); } }
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()); }
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(); } }
/// <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"); }
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------------------- 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); }