private void PredictForCFModel(MLEntityPredictor predictor) { var modelLoader = ClassFactory.Get <IMLModelLoader>(); if (!modelLoader.TryLoadModelForPrediction(UserConnection, MLModelId, out MLModelConfig modelConfig)) { throw new InvalidObjectStateException($"Recommendation model with id {MLModelId} was not found" + " or not ready for making predictions."); } if (modelConfig.CFResultSchemaUId.IsEmpty()) { throw new NotImplementedException($"Model {MLModelId} is not configured for saving results"); } EntitySchema modelRootSchema = UserConnection.EntitySchemaManager .GetInstanceByUId(modelConfig.EntitySchemaId); EntitySchemaQuery usersEsq = GetCFSchemaDataEsq(modelRootSchema, modelConfig.CFUserColumnPath, CFUserFilterData); IEnumerable <Guid> users = ReadCFData(usersEsq); EntitySchemaQuery itemsEsq = GetCFSchemaDataEsq(modelRootSchema, modelConfig.CFItemColumnPath, CFItemFilterData); bool isItemsFilterEmpty = itemsEsq.Filters.IsEmpty(); IEnumerable <Guid> items = isItemsFilterEmpty ? Enumerable.Empty <Guid>() : ReadCFData(itemsEsq); RecommendationFilterItemsMode filterItemsMode = isItemsFilterEmpty ? RecommendationFilterItemsMode.Black : RecommendationFilterItemsMode.White; predictor.Recommend(MLModelId, users.ToList(), CFTopN, items.ToList(), filterItemsMode: filterItemsMode, filterAlreadyInteractedItems: CFFilterAlreadyInteractedItems); }
private void AppendAvailableRecordIds(List <string> availableRecordIdentifiers, EntityCollection rightsCollection, string entityName, ESSearchResponse esResponse) { if (GetIsFileEntity(entityName)) { var availableIds = rightsCollection.Select(e => e.PrimaryColumnValue.ToString().ToLower()); try { EntitySchema fileSchema = _userConnection.EntitySchemaManager.FindInstanceByName(entityName); var parentColumnName = entityName.Replace(FileEntityNameSuffix, ""); var column = fileSchema.Columns.FindByName(parentColumnName); if (column != null) { var masterPrimaryColumnAlias = GlobalSearchColumnUtils.GetPrimaryColumnAlias(column, entityName); var availableFileHits = _userConnection.DBSecurityEngine.GetSchemaUseMasterRecordRights(entityName) ? esResponse.SearchResult.Hits.Where( x => x.Type == entityName && availableIds.Contains(x.Id.ToLower())).ToList() : esResponse.SearchResult.Hits.Where( x => x.Source.ContainsKey(masterPrimaryColumnAlias) && x.Type == entityName && availableIds.Contains(x.Source[masterPrimaryColumnAlias].ToLower())).ToList(); availableRecordIdentifiers.AddRange(availableFileHits.Select(x => x.Id.ToLower())); } } catch (Exception ex) { _log.ErrorFormat(@"Entity name: {0}, Identifiers: {1} Exception: {2}" , entityName, string.Join(", ", availableIds), ex.Message); } return; } availableRecordIdentifiers.AddRange(rightsCollection .Select(e => e.PrimaryColumnValue.ToString().ToLower())); }
private static void FillDisplayValues(UserConnection userConnection, List <LocalizedFeatureWeight> features, Dictionary <string, ColumnExpression> columnExpressionMapping, Guid entitySchemaId, ModelSchemaMetadata metadata) { EntitySchema schema = userConnection.EntitySchemaManager.GetInstanceByUId(entitySchemaId); foreach (var input in metadata.Inputs) { var feature = features.Find(featureWeight => featureWeight.Name == input.Name); if (feature == null) { continue; } bool isBooleanValue = input.Type == "Boolean" || input.Transformations != null && input.Transformations.Exists(transformation => transformation.Operation == "isNotNull"); if (isBooleanValue) { FillBooleanDisplayValue(userConnection, feature); continue; } if (input.Type != "Lookup") { continue; } FillLookupDisplayValue(userConnection, columnExpressionMapping, feature, input, schema); } }
private object GetParameterLookupValue(ProcessSchemaParameter parameter) { var value = GetParameterValue(parameter); var primaryColumnValue = (Guid?)value; if (primaryColumnValue?.IsEmpty() != false) { return null; } var displayValue = string.Empty; if (parameter.ParentMetaSchema == null) { parameter.ParentMetaSchema = Owner.Schema; Log.Warn("[PreconfiguredPageUserTask]. Parameter metadata modified at runtime."); } EntitySchema referenceSchema = parameter.ReferenceSchema; if (referenceSchema.PrimaryDisplayColumn != null) { Entity entity = referenceSchema.CreateEntity(UserConnection); entity.UseAdminRights = false; var columns = new Collection<CoreEntitySchemaColumn>() { referenceSchema.PrimaryDisplayColumn }; entity.FetchFromDB(referenceSchema.PrimaryColumn, primaryColumnValue.Value, columns); displayValue = entity.PrimaryDisplayColumnValue; } return new LookupColumnValue { Value = primaryColumnValue.Value.ToString(), DisplayValue = displayValue }; }
private Dictionary <string, List <string> > PrepareFileRightsConditions(ESSearchResponse esResponse, Dictionary <string, List <string> > conditions) { var entityName = conditions.First().Key; var listOfIds = conditions.First().Value; var parentEntityName = entityName.Replace(FileEntityNameSuffix, ""); var parentEntity = _userConnection.EntitySchemaManager.FindInstanceByName(parentEntityName); if (parentEntity != null) { try { var currentFileHits = esResponse.SearchResult.Hits.Where(x => listOfIds.Contains(x.Id)).ToList(); EntitySchema fileSchema = _userConnection.EntitySchemaManager.FindInstanceByName(entityName); var column = fileSchema.Columns.FindByName(parentEntityName); if (column != null) { var masterPrimaryColumnAlias = GlobalSearchColumnUtils.GetPrimaryColumnAlias(column, entityName); return(new Dictionary <string, List <string> > { { parentEntityName, currentFileHits .Where(x => x.Source.ContainsKey(masterPrimaryColumnAlias)) .Select(x => x.Source[masterPrimaryColumnAlias]).ToList() } }); } } catch (Exception ex) { _log.ErrorFormat(@"Entity name: {0}, Identifiers: {1} Exception: {2}" , entityName, string.Join(", ", listOfIds), ex.Message); } } return(conditions); }
private void AddColumnUIds() { if (_columnUIds.IsNullOrEmpty()) { return; } UserConnection userConnection = _select.UserConnection; string rootSchemaName = _select.SourceExpression.SchemaName; string rootSchemaAlias = _select.SourceExpression.Alias; EntitySchema entitySchema = userConnection.EntitySchemaManager.GetInstanceByName(rootSchemaName); foreach (Guid columnUId in _columnUIds) { string columnName = entitySchema.Columns.GetByUId(columnUId).ColumnValueName; if (_select.Columns.Any(expression => expression.ExpressionType == QueryColumnExpressionType.SourceColumnAlias && expression.SourceAlias == rootSchemaAlias && expression.SourceColumnAlias == columnName)) { continue; } string sourceAlias = rootSchemaAlias ?? rootSchemaName; string columnAlias = GetRootColumnAlias(columnName); _replacedColumnAliases[columnName] = columnAlias; _select.Column(sourceAlias, columnName).As(columnAlias); } }
public VisaHelper(Guid sysAdminUnitId, UserConnection userConnection) { _sysAdminUnitId = sysAdminUnitId; _userConnection = userConnection; _baseVisaSchema = GetExtendedBaseVisaEntitySchema(); _baseVisaESQ = GetExtendedBaseVisaESQ(_baseVisaSchema); }
private static string GetSchemaColumnFullCaption(UserConnection userConnection, Guid rootSchemaUId, string columnPath) { EntitySchema schema = userConnection.EntitySchemaManager.GetInstanceByUId(rootSchemaUId); return(schema.GetSchemaColumnFullCaptionByPath(columnPath)); }
/// <summary> /// Determines whether the conditions is satisfied. /// </summary> /// <returns><c>true</c> when conditions are successfully checked; otherwise - <c>false</c>.</returns> public virtual bool GetIsMatchedConditions() { if (!IsMatchConditions || DataSourceFilters.IsNullOrEmpty()) { return(true); } CoreEntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByUId(ObjectSchemaId); var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, entitySchema.Name) { UseAdminRights = false }; esq.AddColumn(entitySchema.PrimaryColumn.Name); ProcessUserTaskUtilities.SpecifyESQFilters(UserConnection, this, entitySchema, esq, DataSourceFilters); if (esq.Filters.Count == 0) { return(true); } if (esq.Filters.Count == 1) { if (esq.Filters[0] is EntitySchemaQueryFilterCollection filterGroup && filterGroup.Count == 0) { return(true); } } Entity entity = esq.GetEntity(UserConnection, RecordId); return(entity != null); }
/// <summary> /// Sets up full rights for the owner of the feed. /// </summary> /// <param name="socialSubscription">The feed to which access rights are being given.</param> private void SetOwnerDefaultRights(SocialSubscription socialSubscription) { Guid socialSubscriptionId = socialSubscription.Id; Guid socialChannelOwnerId = GetSocialChannelOwnerId(socialSubscriptionId, socialSubscription.EntityId); if (socialChannelOwnerId.Equals(UserConnection.CurrentUser.ContactId)) { return; } if (socialChannelOwnerId.IsEmpty()) { return; } CoreEntitySchema schema = UserConnection.EntitySchemaManager.GetInstanceByName("SocialSubscription"); if (!schema.AdministratedByRecords) { return; } Guid ownerUserId = FindOwnerUserId(socialChannelOwnerId); if (ownerUserId.IsEmpty()) { return; } SetEntitySchemaRecordRightLevel(ownerUserId, schema.Name, socialSubscriptionId, EntitySchemaRecordRightLevel.AllowAndGrant, schema.UseDenyRecordRights); }
/// <inheritdoc /> protected override bool InternalExecute(ProcessExecutingContext context) { bool isRedo = (Status == ProcessStatus.Error && CurrentActivityId == Guid.Empty && !ProcessUserTaskUtilities.GetIsActivityCreated(UserConnection, UId)); bool isRunning = !CurrentActivityId.Equals(Guid.Empty) && !IsActivityCompleted; if (!isRunning || isRedo) { var editMode = (RecordEditMode)Enum.ToObject(typeof(RecordEditMode), EditMode); bool isActivityEntitySchema = GetIsActivityEntitySchema(); Entity activity = null; IProcessEngine processEngine = UserConnection.ProcessEngine; if (isActivityEntitySchema) { if (editMode == RecordEditMode.New) { activity = CreateActivity(); RecordId = CurrentActivityId; } else { CurrentActivityId = RecordId; } } else { Entity accompaningActivity = CreateAccompaningActivity(); CoreEntitySchema activityEntitySchema = GetActivityEntitySchema(); Guid resultColumnUId = activityEntitySchema.Columns.GetByName("Status").UId; processEngine.AddProcessListener(accompaningActivity, UId, GetConditionData(resultColumnUId, accompaningActivity)); if (editMode == RecordEditMode.New) { RecordId = Guid.NewGuid(); } } string serializedFilters = IsMatchConditions && DataSourceFilters.IsNotNullOrEmpty() ? ConvertToProcessDataSourceFilters(ObjectSchemaId, DataSourceFilters) : null; if (activity == null) { if (editMode != RecordEditMode.New) { processEngine.AddProcessListener(RecordId, ObjectSchemaId, UId, serializedFilters); } else { processEngine.AddProcessListener(RecordId, ObjectSchemaId, UId, null, null, EntityChangeType.Inserted); } } else { processEngine.AddProcessListener(activity, UId, serializedFilters); } } InteractWithUser(context, isRunning, ShowExecutionPage); return(false); }
private EntitySchemaQuery GetExtendedBaseVisaESQ(CoreEntitySchema schema) { EntitySchemaQuery entitySchemaQuery = new EntitySchemaQuery(schema); entitySchemaQuery.RootSchema.IsVirtual = false; entitySchemaQuery.AddAllSchemaColumns(); return(entitySchemaQuery); }
private void ApplySectionScoreSettings(string sectionEntityName, List <ESMultiMatchQuery> multiMatchQueries, EntitySchema currentSectionEntity, List <ESFunction> functions) { foreach (var esMultiMatchQuery in multiMatchQueries) { AppendDefaultPrimaryColumnField(currentSectionEntity, esMultiMatchQuery); } AppendDefaultFunction(functions, sectionEntityName); }
private int GetFilledColumnRowCount(UserConnection userConnection, EntitySchema entitySchema, EntitySchemaColumn column, IEntitySchemaQueryFilterItem filter) { EntitySchemaQuery query = new EntitySchemaQuery(entitySchema); query.AddColumn(query.RootSchema.GetPrimaryColumnName()).SummaryType = AggregationType.Count; query.Filters.Add(CreateEmptyColumnValueFilter(query, column)); query.Filters.Add(filter); return(query.GetSummarySelectQuery(userConnection).ExecuteScalar <int>()); }
private void AppendDefaultPrimaryColumnField(EntitySchema entitySchema, ESMultiMatchQuery multiMatchQuery) { var primaryColumn = entitySchema.PrimaryDisplayColumn; if (primaryColumn != null) { var alias = GlobalSearchColumnUtils.GetAlias(primaryColumn, entitySchema); if (!multiMatchQuery.Fields.Any(x => x.Contains(alias))) { multiMatchQuery.Fields.Add(string.Format("{0}^{1}", alias, PrimaryColumnDefaultWeight)); } } }
/// <summary> /// Determines whether the current process element is executed. /// </summary> /// <returns></returns> public virtual bool GetIsExecuted() { CoreEntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByUId(ObjectSchemaId); var select = (Select) new Select(UserConnection) .Column("Id") .From(entitySchema.Name) .Where("Id").IsEqual(Column.Parameter(RecordId)); using (DBExecutor dbExecutor = UserConnection.EnsureDBConnection()) { using (IDataReader dataReader = select.ExecuteReader(dbExecutor)) { return(dataReader.Read()); } } }
private CoreEntitySchema GetExtendedBaseVisaEntitySchema() { var entitySchemaManager = _userConnection.GetSchemaManager("EntitySchemaManager") as EntitySchemaManager; var baseVisaEntitySchema = entitySchemaManager.GetInstanceByName("BaseVisa"); CoreEntitySchema baseVisaSchema = new CoreEntitySchema(baseVisaEntitySchema, false); baseVisaSchema.AddColumn("LongText", "Title"); baseVisaSchema.AddColumn("LongText", "VisaSchemaName"); baseVisaSchema.AddColumn("Guid", "VisaObjectId"); baseVisaSchema.AddColumn("Guid", "VisaSchemaTypeId"); baseVisaSchema.AddColumn("LongText", "VisaTypeName"); baseVisaSchema.AddColumn("LongText", "VisaSchemaCaption"); baseVisaSchema.AddColumn("LongText", "SchemaName"); return(baseVisaSchema); }
private object GetParameterLookupValue(ProcessSchemaParameter parameter, IReadOnlyDictionary <Guid, Guid> sysModuleEntityPageType) { object value = GetParameterValue(parameter); var primaryColumnValue = (Guid?)value; if (primaryColumnValue?.IsEmpty() != false) { return(null); } if (parameter.ParentMetaSchema == null) { parameter.ParentMetaSchema = Owner.Schema; Log.Warn("[PreconfiguredPageUserTask]. Parameter metadata modified at runtime."); } EntitySchema referenceSchema = parameter.ReferenceSchema; if (referenceSchema.PrimaryDisplayColumn == null) { return(new { value = primaryColumnValue.Value.ToString() }); } Entity entity = referenceSchema.CreateEntity(UserConnection); entity.UseAdminRights = false; var columnsToFetch = new Collection <CoreEntitySchemaColumn>() { referenceSchema.PrimaryColumn, referenceSchema.PrimaryDisplayColumn, }; var hasPageTypeColumn = sysModuleEntityPageType.ContainsKey(referenceSchema.UId); CoreEntitySchemaColumn pageTypeColumn = null; if (hasPageTypeColumn) { Guid typeColumnUId = sysModuleEntityPageType[referenceSchema.UId]; pageTypeColumn = referenceSchema.Columns.FindByUId(typeColumnUId); if (pageTypeColumn != null) { columnsToFetch.Add(pageTypeColumn); } } entity.FetchFromDB(referenceSchema.PrimaryColumn, primaryColumnValue.Value, columnsToFetch, false); ExpandoObject lookupValue = GetClientLookupLinkValue(entity, pageTypeColumn); return(lookupValue); }
private EntitySchemaQuery GetEntitySchemaQuery(string customPrefix, EntitySchema entitySchema) { if (_esqByPrefix.TryGetValue(customPrefix, out var cachedEsq)) { return(cachedEsq); } var esq = new EntitySchemaQuery(entitySchema) { IgnoreDisplayValues = true, SchemaAliasPrefix = customPrefix }; esq.PrimaryQueryColumn.IsVisible = true; _esqByPrefix[customPrefix] = esq; return(esq); }
/// <inheritdoc /> public override string GetExecutionData() { CoreEntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByUId(ObjectSchemaId); var defaultColumnValues = new Dictionary <string, object>(); foreach (var columnValue in RecordColumnValues.Values) { var column = entitySchema.GetSchemaColumnByMetaPath(columnValue.Key); if ((column.DataValueType is LookupDataValueType || column.DataValueType is MultiLookupDataValueType) && ((Guid)columnValue.Value).IsEmpty()) { continue; } defaultColumnValues[column.Name] = SerializeEntityColumn(column, columnValue.Value); } var editMode = (RecordEditMode)Enum.ToObject(typeof(RecordEditMode), EditMode); if (editMode == RecordEditMode.New) { EntitySchemaColumnCollection columns = entitySchema.Columns; defaultColumnValues["ProcessListeners"] = SerializeEntityColumn(columns.GetByName("ProcessListeners"), (int)EntityChangeType.Inserted); } string actionName = GetActionName(); string informationOnStep = LocalizableString.IsNullOrEmpty(InformationOnStep) ? GetParameterValue("InformationOnStep")?.ToString() ?? string.Empty : InformationOnStep.Value; return(SerializeToString(new { processId = ProcessUserTaskUtilities.GetParentProcessId(Owner), procElUId = UId, name = Name, isProcessExecutedBySignal = ProcessUserTaskUtilities.GetIsProcessExecutedBySignal(Owner), processName = Owner.Name, action = actionName, entitySchemaName = entitySchema.Name, recordId = RecordId, activityRecordId = CurrentActivityId, recommendation = GetActivityTitle(), informationOnStep, defaultValues = defaultColumnValues.Count > 0 ? defaultColumnValues : null, executionContext = ExecutionContext, completeExecution = actionName == "add", pageTypeId = PageTypeUId == Guid.Empty ? string.Empty : PageTypeUId.ToString(), nextProcElUId = "nextProcElUIdValue" })); }
private EntitySchemaQuery GetCFSchemaDataEsq(EntitySchema modelRootSchema, string cfColumnPath, string filterData) { EntitySchema cfColumnSchema = modelRootSchema.GetSchemaColumnByPath(cfColumnPath).ReferenceSchema; var esq = new EntitySchemaQuery(cfColumnSchema); esq.PrimaryQueryColumn.IsAlwaysSelect = true; var converter = new FilterEditConverter(UserConnection); IEntitySchemaQueryFilterItem filter = converter.ConvertToEntitySchemaQueryFilterItem(esq, Owner, filterData); if (!filter.GetFilterInstances().IsEmpty()) { esq.Filters.Add(filter); } return(esq); }
/// <summary> /// Returns type of the activity. /// </summary> /// <returns>Lookup value.</returns> public virtual Guid GetActivityType() { CoreEntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByUId(ObjectSchemaId); foreach (var columnValue in RecordColumnValues.Values) { CoreEntitySchemaColumn column = entitySchema.GetSchemaColumnByMetaPath(columnValue.Key); if (column.Name == "Type" && columnValue.Value != null) { var typeId = (Guid)columnValue.Value; if (typeId != Guid.Empty) { return(typeId); } } } return(PageTypeUId); }
private Select GetSelectByFilterData(UserConnection userConnection, byte[] filterEditData, string rootSchemaName, string customPrefix) { EntitySchema entitySchema = userConnection.EntitySchemaManager.GetInstanceByName(rootSchemaName); IEntitySchemaQueryFilterItem filters = CommonUtilities.ConvertClientFilterDataToEsqFilters(userConnection, filterEditData, entitySchema.UId, customPrefix); var esq = GetEntitySchemaQuery(customPrefix, entitySchema); if (filters.GetFilterInstances().IsEmpty()) { return(esq.GetSelectQuery(userConnection)); } esq.Filters.Add(CommonUtilities.ConvertClientFilterDataToEsqFilters(userConnection, filterEditData, entitySchema.UId, customPrefix)); Select esqSelect = esq.GetSelectQuery(userConnection); return(esqSelect); }
private BpmSearchResponseEntity FillBpmResponseEntity(ESHit esHit) { _entityName = esHit.Type; _entitySchema = _userConnection.EntitySchemaManager.GetInstanceByName(_entityName); var responseEntity = new BpmSearchResponseEntity { Id = esHit.Id, EntityName = _entityName, ColumnValues = new Dictionary <string, object>(), FoundColumns = new Dictionary <string, string[]>() }; var columnValues = responseEntity.ColumnValues; var foundColumns = responseEntity.FoundColumns; var availableColumns = _entitySchema.Columns .Where(x => _userConnection.DBSecurityEngine .GetIsEntitySchemaColumnReadingAllowed(_entitySchema.Name, x.IsLookupType ? $"{x.Name}{x.ReferenceSchema.PrimaryColumn.Name}" : x.Name)); if (UseLocalizableGlobalSearchResult) { var entityValues = GetLocalizableEntityValues(_entitySchema, Guid.Parse(esHit.Id), availableColumns); foreach (var column in availableColumns) { columnValues.Add(column.Name, entityValues[column.Name]); AddHighlights(esHit, column, foundColumns, columnValues); } } else { foreach (var column in availableColumns) { if (column.IsLookupType) { AddLookupColumnValue(esHit, column, columnValues); } else { AddColumnValue(esHit, column, columnValues); } AddHighlights(esHit, column, foundColumns, columnValues); } } AddDetailsHighlight(responseEntity, esHit); return(responseEntity); }
private Dictionary <string, object> GetLocalizableEntityValues(EntitySchema entitySchema, Guid recordId, IEnumerable <EntitySchemaColumn> availableColumns) { var esq = new EntitySchemaQuery(entitySchema); esq.PrimaryQueryColumn.IsAlwaysSelect = true; var serverClientColumnMap = new Dictionary <string, string>(); foreach (var c in availableColumns) { esq.AddColumn(c.Name); serverClientColumnMap.Add(c.Name, c.Name); } esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, esq.RootSchema.GetPrimaryColumnName(), recordId)); return(Nui.ServiceModel.Extensions.QueryExtension .GetEntityCollection(esq.GetEntityCollection(_userConnection), serverClientColumnMap) .First()); }
/// <summary> /// Adds columns of the select's root entity schema. /// </summary> /// <param name="columnExpressions">Column expressions.</param> /// <returns>Current instance of <see cref="ISelectQueryBuilder"/></returns> public ISelectQueryBuilder AddColumns(IEnumerable <ColumnExpression> columnExpressions) { List <ColumnExpression> columnExpressionList = columnExpressions?.ToList(); if (columnExpressionList.IsNullOrEmpty()) { return(this); } UserConnection userConnection = _select.UserConnection; string rootSchemaName = _select.SourceExpression.SchemaName; EntitySchema entitySchema = userConnection.EntitySchemaManager.GetInstanceByName(rootSchemaName); var esq = GetEntitySchemaQuery(Prefix, entitySchema); // ReSharper disable once PossibleNullReferenceException columnExpressionList.ForEach(columnExpression => { _columnMapping[columnExpression] = columnExpression.AggregationType != AggregationType.None ? AddReverseAggregationColumn(userConnection, columnExpression, esq) : esq.AddColumn(columnExpression.ColumnPath); }); return(this); }
/// <summary> /// Returns unique identifier of the contact who created the feed. /// </summary> /// <param name="socialSubscriptionId">Subscription unique identifier.</param> /// <param name="entityId">Entity unique identifier.</param> private Guid GetSocialChannelOwnerId(Guid socialSubscriptionId, Guid entityId) { CoreEntitySchema schema = GetSchema(socialSubscriptionId); var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, schema.Name); EntitySchemaQueryColumn ownerColumn; var ownerColumnExist = schema.Columns.Any(c => c.Name == "Owner"); if (ownerColumnExist) { ownerColumn = esq.AddColumn("Owner"); } else { ownerColumn = esq.AddColumn("CreatedBy"); } Entity socialChannel = esq.GetEntity(UserConnection, entityId); CoreEntitySchemaColumn entitySchemaColumn = socialChannel.Schema.FindSchemaColumnByPath(ownerColumn.Name); Guid ownerId = socialChannel.GetTypedColumnValue <Guid>(entitySchemaColumn); return(ownerId); }
private static void FillLookupDisplayValue(UserConnection userConnection, Dictionary <string, ColumnExpression> columnExpressionMapping, LocalizedFeatureWeight feature, ModelSchemaInput input, EntitySchema schema) { if (!Guid.TryParse(feature?.Value, out Guid id)) { return; } EntitySchema referenceSchema; if (input.ReferenceSchemaName.IsNullOrEmpty()) { if (!columnExpressionMapping.TryGetValue(input.Name, out ColumnExpression columnExpression)) { return; } EntitySchemaColumn column = schema.FindSchemaColumnByPath(columnExpression.ColumnPath); if (column == null || !column.IsLookupType || column.ReferenceSchema == null) { return; } referenceSchema = column.ReferenceSchema; } else { referenceSchema = userConnection.EntitySchemaManager.FindInstanceByName(input.ReferenceSchemaName); } if (referenceSchema == null) { return; } Entity lookupEntity = referenceSchema.CreateEntity(userConnection); if (!lookupEntity.FetchPrimaryInfoFromDB(referenceSchema.PrimaryColumn, id)) { return; } feature.DisplayValue = lookupEntity.PrimaryDisplayColumnValue; }
public static decimal GetCurrencyRate(Guid currencyId, UserConnection userConnection) { var rateSelect = new Select(userConnection).Top(1) .Column("StartDate") .Column("Currency", "Division").As("Division") .Column("Rate").As("Rate") .From("CurrencyRate") .Join(JoinType.Inner, "Currency") .On("Currency", "Id").IsEqual(Column.Parameter(currencyId)) .Where("StartDate").IsLessOrEqual(Column.Parameter(DateTime.Today)) .And("CurrencyId").IsEqual(Column.Parameter(currencyId)) .OrderByDesc("StartDate") as Select; var entitySchemaManager = userConnection.GetSchemaManager("EntitySchemaManager") as EntitySchemaManager; Terrasoft.Core.Entities.EntitySchema wSchema = new Terrasoft.Core.Entities.EntitySchema(entitySchemaManager); EntityCollection coll = new EntityCollection(userConnection, wSchema); using (DBExecutor dbExecutor = userConnection.EnsureDBConnection()) { using (IDataReader dataReader = rateSelect.ExecuteReader(dbExecutor)) { coll.Load(dataReader); } } if (coll.Count > 0) { var currencyDivision = coll[0].GetTypedColumnValue <Int32>("Division"); var currencyRate = coll[0].GetTypedColumnValue <Decimal>("Rate"); if (currencyDivision == 0) { currencyDivision = 1; } var rate = Math.Round(currencyRate / currencyDivision, 2); return(rate); } else { return(1); } }
/// <summary> /// Creates entity of the Activity. /// </summary> /// <returns>A new instance of the entity.</returns> public virtual Entity CreateActivity() { CoreEntitySchema activitySchema = GetActivityEntitySchema(); Entity activity = activitySchema.CreateEntity(UserConnection); activity.UseAdminRights = false; string activityTitle = GetActivityTitle(); activity.SetColumnValue("Title", activityTitle); activity.SetDefColumnValues(); foreach (KeyValuePair <string, object> columnValue in RecordColumnValues.Values) { CoreEntitySchemaColumn column = activitySchema.GetSchemaColumnByMetaPath(columnValue.Key); if ((column.DataValueType is LookupDataValueType || column.DataValueType is MultiLookupDataValueType) && ((Guid)columnValue.Value).IsEmpty()) { continue; } activity.SetColumnValue(column, columnValue.Value); } var columnDocument = activity.Schema.Columns.FindByName("Document"); if (columnDocument != null) { object document = activity.GetColumnValue(columnDocument); if (document != null) { Document = (Guid)document; } } SpecifyActivityColumnValues(activity); CurrentActivityId = activity.PrimaryColumnValue; IsActivityCompleted = false; PageTypeUId = GetActivityType(); return(activity); }