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);
}
