//TO Do
public List<IChildProject> GetChildProjects()
{
var userConnection = TerrasoftApi.GetuserConnection();
var projectList = new List<IChildProject>();
var esqProjects = new EntitySchemaQuery(userConnection.EntitySchemaManager, "Project");
esqProjects.AddColumn("ParentProject");
esqProjects.AddColumn("EndDate");
esqProjects.AddColumn("StartDate");
esqProjects.JoinRightState = QueryJoinRightLevel.Disabled;
esqProjects.PrimaryQueryColumn.IsAlwaysSelect = true;
var filterId = esqProjects.CreateFilterWithParameters(FilterComparisonType.Equal, "ParentProject", RootId);
esqProjects.Filters.Add(filterId);
var projectEntities = esqProjects.GetEntityCollection(userConnection);
foreach (var project in projectEntities)
{
var id = (Guid)project.PrimaryColumnValue;
var parentProjectId = (Guid)project.GetColumnValue("ParentProjectId");
var endDate = (DateTime)project.GetColumnValue("EndDate");
var startDate = (DateTime)project.GetColumnValue("StartDate");
var newProject = new ChildProject(RootId, id, endDate, startDate);
if (ChildProjects == null) ChildProjects = new List<ChildProject>();
ChildProjects.Add(newProject);
}
var orderedChildProjecs = ChildProjects.OrderBy(x => x.StartDate).ToList() as List<ChildProject>;
foreach (var item in orderedChildProjecs)
{
projectList.Add((IChildProject)item);
}
ChildProjects = orderedChildProjecs;
return projectList;
}
/// <summary>
/// Get dictionary of params and values for calculation.
/// </summary>
/// <param name="paramsDictionary">List of params.</param>
/// <param name="caseId">Id of current case.</param>
/// <returns>Dictionary of params and values for calculation.</returns>
protected virtual Dictionary <string, object> GetParamsDictionary(Dictionary <string, string> paramsDictionary, Guid caseId)
{
var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "Case");
Dictionary <string, string> paramNames = new Dictionary <string, string>();
foreach (var name in paramsDictionary.Keys)
{
paramNames.Add(esq.AddColumn(name).Name, paramsDictionary[name]);
}
Entity entity = esq.GetEntity(UserConnection, caseId);
Dictionary <string, object> resultDictionary = new Dictionary <string, object>();
foreach (var name in paramNames.Keys)
{
resultDictionary.Add(paramNames[name], entity.GetColumnValue(name));
}
return(resultDictionary);
}
private List <ScoringModel> GetScoringModels()
{
var models = new List <ScoringModel>();
EntitySchema schema = UserConnection.EntitySchemaManager.GetInstanceByName("ScoringModel");
EntitySchemaQuery esq = new EntitySchemaQuery(schema);
esq.PrimaryQueryColumn.IsAlwaysSelect = true;
esq.IgnoreDisplayValues = true;
esq.AddAllSchemaColumns();
EntityCollection entityCollection = esq.GetEntityCollection(UserConnection);
foreach (Entity scoringModelEntity in entityCollection)
{
ScoringModel model = CreateScoringModel(scoringModelEntity);
models.Add(model);
}
return(models);
}
public IEnumerable <EngineType> GetActualEngineTypes(string showroomId)
{
var esq = new EntitySchemaQuery(_userConnection.EntitySchemaManager, "IteCar");
esq.IsDistinct = true;
var engineTypeIdCol = esq.AddColumn("IteEngineType.Id");
var engineTypeNameCol = esq.AddColumn("IteEngineType.Name");
var esqFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "IteShowroom.Id", showroomId);
esq.Filters.Add(esqFilter);
var entities = esq.GetEntityCollection(_userConnection);
var actualEngineTypes = entities.Select(x => new EngineType {
Id = x.GetTypedColumnValue <Guid>(engineTypeIdCol.Name),
Name = x.GetTypedColumnValue <string>(engineTypeNameCol.Name)
});
return(actualEngineTypes);
}
public string GetCurrentUserHomePage()
{
var userId = UserConnection.CurrentUser.Id;
var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "SysAdminUnit")
{
UseAdminRights = false,
IgnoreDisplayValues = true,
Cache = UserConnection.SessionCache.WithLocalCaching("HomePage"),
CacheItemName = $"HomePage_{userId}"
};
esq.PrimaryQueryColumn.IsVisible = false;
var column = esq.AddColumn("HomePage.Code");
var entity = esq.GetEntity(UserConnection, userId);
return(entity?.GetTypedColumnValue <string>(column.Name));
}
private bool HasDayOfWeekOverrides(Guid treeGridRecordId)
{
if (!CurrentDaysGridData.Keys.Contains(treeGridRecordId))
{
return(false);
}
DateTime date = CurrentDaysGridData[treeGridRecordId].Date.Date;
var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "DayInCalendar");
esq.AddColumn("Id");
esq.RowCount = 1;
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Calendar",
_page.DataSource.ActiveRowPrimaryColumnValue));
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.IsNull, "Date"));
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "DayOfWeek.Number",
CalendarUtils.GetDayOfWeekNumber(date)));
return(esq.GetEntityCollection(UserConnection).Any());
}
/// <summary>
/// Start event tracking.
/// </summary>
/// <param name="userConnection">UserConnection.</param>
/// <param name="apiKey">Api key.</param>
/// <returns>Result code.</returns>
public static int StartTracking(UserConnection userConnection, string apiKey)
{
var apiKeyRequest = new ApiKeyRequest();
string eventTrackingLogin = SysSettings.GetValue(userConnection,
"EventTrackingLogin").ToString();
string eventTrackingPassword = SysSettings.GetValue(userConnection,
"EventTrackingPassword").ToString();
SysSettings.SetDefValue(userConnection, "EventTrackingApiKey", apiKey);
string eventTrackingWebAppUrl = SysSettings.GetValue(userConnection,
"EventTrackingWebAppUrl").ToString() + "/SetupTracking?format=json";
string bpmUrl = SysSettings.GetValue(userConnection,
"BpmEventTrackingServiceUrl").ToString();
string bpmAuthKey = SysSettings.GetValue(userConnection,
"BpmAuthKey").ToString();
if (string.IsNullOrEmpty(bpmUrl) || string.IsNullOrEmpty(bpmAuthKey))
{
return((int)EventTrackingResult.SysSettingIsEmpty);
}
var trackingDomainESQ = new EntitySchemaQuery(userConnection.EntitySchemaManager, "TrackingDomain");
var nameColumn = trackingDomainESQ.AddColumn("Name");
var trackingDomainCollection = trackingDomainESQ.GetEntityCollection(userConnection);
apiKeyRequest.TrackingDomainList = trackingDomainCollection.Select(item =>
item.GetColumnValue(nameColumn.Name).ToString()).ToList();
if (!apiKeyRequest.TrackingDomainList.Any())
{
return((int)EventTrackingResult.DomainIsEmpty);
}
apiKeyRequest.SetBasicAuth(eventTrackingLogin, eventTrackingPassword);
apiKeyRequest.SetRequestMethod("POST");
apiKeyRequest.ApiKey = apiKey;
apiKeyRequest.BpmAuthKey = bpmAuthKey;
apiKeyRequest.BpmUrl = bpmUrl;
int result = apiKeyRequest.Execute(eventTrackingWebAppUrl);
if (!apiKeyRequest.Success)
{
return((int)EventTrackingResult.OtherError);
}
EventTypePostProcess.SetEventType(userConnection);
return(result);
}
public static void SaveLocalizableValue(Entity entity, LocalizableString localizableValue, string columnName)
{
if (UseMultilanguageData)
{
return;
}
var userConnection = entity.UserConnection;
var entitySchemaManager = userConnection.EntitySchemaManager;
var query = new EntitySchemaQuery(entitySchemaManager, "SysCulture");
var idColumnName = query.AddColumn("Id").Name;
var nameColumnName = query.AddColumn("Name").Name;
var sysCultures = query.GetEntityCollection(userConnection);
string lczSchemaName = entity.Schema.GetLocalizableStringsSchemaName();
var lczSchema = entitySchemaManager.GetInstanceByName(lczSchemaName);
foreach (var sysCulture in sysCultures)
{
string cultureName = sysCulture.GetTypedColumnValue <string>(nameColumnName);
var culture = CultureInfo.GetCultureInfo(cultureName);
string lczValue = string.Empty;
if (!localizableValue.HasCultureValue(culture))
{
lczValue = localizableValue.GetCultureValue(GeneralResourceStorage.CurrentCulture);
}
else
{
lczValue = localizableValue.GetCultureValue(culture);
}
Guid cultureId = sysCulture.GetTypedColumnValue <Guid>(idColumnName);
Guid columnUId = entity.Schema.Columns.FindByName(columnName).UId;
Entity newLczValueEntity = lczSchema.CreateEntity(userConnection);
newLczValueEntity.SetDefColumnValues();
newLczValueEntity.FetchFromDB(new Dictionary <string, object> {
{ "SysCulture", cultureId },
{ "Record", entity.PrimaryColumnValue },
{ "ColumnUId", columnUId },
});
newLczValueEntity.SetColumnValue("SysCultureId", cultureId);
newLczValueEntity.SetColumnValue("ColumnUId", columnUId);
newLczValueEntity.SetColumnValue("Value", lczValue);
newLczValueEntity.SetColumnValue("RecordId", entity.PrimaryColumnValue);
newLczValueEntity.Save();
}
}
public virtual void Send(Guid sysAdminUnitId, string title, string message, Dictionary <string, string> additionalData)
{
if (!_userConnection.GetIsFeatureEnabled("UseMobilePushNotifications"))
{
return;
}
EntitySchema schema = _userConnection.EntitySchemaManager.GetInstanceByName("PushNotificationToken");
var esq = new EntitySchemaQuery(schema);
EntitySchemaQueryColumn tokenColumn = esq.AddColumn("Token");
EntitySchemaQueryColumn settingsColumn = esq.AddColumn("=Service.Settings");
EntitySchemaQueryColumn classNameColumn = esq.AddColumn("=Service.ClassName");
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "SysAdminUnit.Id", sysAdminUnitId));
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Service.Enabled", true));
esq.IsDistinct = true;
EntityCollection entityCollection = esq.GetEntityCollection(_userConnection);
var providers = new Dictionary <string, IPushNotificationProvider>();
foreach (var item in entityCollection)
{
var token = item.GetTypedColumnValue <string>(tokenColumn.Name);
var settings = item.GetTypedColumnValue <string>(settingsColumn.Name);
var className = item.GetTypedColumnValue <string>(classNameColumn.Name);
IPushNotificationProvider providerInstance = null;
if (!providers.ContainsKey(className))
{
providerInstance = CreateProviderInstance(className, settings);
providers.Add(className, providerInstance);
}
else
{
providers.TryGetValue(className, out providerInstance);
}
var data = new PushNotificationData()
{
Token = token,
Title = title,
Message = message,
AdditionalData = additionalData
};
providerInstance.Send(data);
}
}
/// <summary>
/// ########## #### # #########, ############## ##### #### ######.
/// </summary>
/// <param name="calendarIds">############## ######## ########## ### #######</param>
/// <param name="dayOfWeekNumber">##### ### ######</param>
/// <param name="ignoredIds">############## ####, ####### ## ##### ############ # #######</param>
/// <returns>#### ######</returns>
public DayInCalendar GetWeekDay(IEnumerable <Guid> calendarIds, int dayOfWeekNumber,
IEnumerable <Guid> ignoredIds = null)
{
object[] calendarsIdObjects = calendarIds.Select(id => (object)id).ToArray();
var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "DayInCalendar");
esq = AddAllDayInCalendarColumns(esq);
esq.RowCount = 1;
esq.AddColumn("Calendar.Depth").OrderByDesc();
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Calendar", calendarsIdObjects));
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "DayOfWeek.Number", dayOfWeekNumber));
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.IsNull, "Date"));
if (ignoredIds != null && ignoredIds.Any())
{
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.NotEqual, "Id",
ignoredIds.Select(i => (object)i)));
}
return((DayInCalendar)esq.GetEntityCollection(UserConnection).SingleOrDefault());
}
/// <summary>
/// Get list type of ActualizeAgeItems and calculate age field
/// </summary>
/// <param name="esq"><see cref="EntitySchemaQuery"/>Entity schema query</param>
/// <returns><list of <see cref="ActualizeAgeItem"/>.</returns>
protected virtual List <ActualizeAgeItem> GetItemForActualize(EntitySchemaQuery esq)
{
var resultItems = new List <ActualizeAgeItem>();
Select selectAgeItems = esq.GetSelectQuery(UserConnection);
using (DBExecutor dbExecutor = UserConnection.EnsureDBConnection()) {
using (IDataReader dr = selectAgeItems.ExecuteReader(dbExecutor)) {
while (dr.Read())
{
var itemId = dr.GetColumnValue <Guid>("Id");
var dateItem = dr.GetColumnValue <DateTime>(EntityDateColumn.Name);
var age = CalculateAgeHelper.GetFullAgeYears(dateItem);
var currentAge = dr.GetColumnValue <int>(UpdateEntityColumn.Name);
resultItems.Add(new ActualizeAgeItem(itemId, age, currentAge, dateItem));
}
}
}
return(resultItems);
}
/// <summary>
/// Returns SearchData of the folder.
/// </summary>
/// <param name="userConnection">Instance of the <see cref="Terrasoft.Core.UserConnection"/>.</param>
/// <param name="recordId">Unique identifier of the folder.</param>
/// <param name="folderSchemaUId">Unique identifier of the folder schema.</param>
/// <returns>Search data.</returns>
public static byte[] GetFolderSearchData(UserConnection userConnection, Guid recordId, Guid folderSchemaUId)
{
EntitySchemaManager entitySchemaManager = userConnection.EntitySchemaManager;
EntitySchema schema = entitySchemaManager.GetInstanceByUId(folderSchemaUId);
var esq = new EntitySchemaQuery(schema);
string searchDataColumnName = esq.AddColumn("SearchData").Name;
esq.Filters.Add(
esq.CreateFilterWithParameters(FilterComparisonType.Equal, false, "Id", recordId));
EntityCollection entities = esq.GetEntityCollection(userConnection);
if (!entities.Any())
{
return(null);
}
Entity folderEntity = entities.First();
return(folderEntity.GetBytesValue(searchDataColumnName));
}
private void Save(JiraTaskTrackerData[] data)
{
var schema = _userConnection.EntitySchemaManager.GetInstanceByName("SkProjectTaskTracker");
var esq = new EntitySchemaQuery(schema);
esq.AddAllSchemaColumns();
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal,
"SkProject", _projectId));
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal,
"SkKey", data.Select(x => x.Id).Cast <object>()));
var entityCollection = esq.GetEntityCollection(_userConnection);
List <string> foundKeys = new List <string>();
foreach (var entityCollectionItem in entityCollection)
{
var key = entityCollectionItem.GetTypedColumnValue <string>("SkKey");
foundKeys.Add(key);
var trackerData = data.Where(x => x.Id == key).FirstOrDefault();
if (trackerData != null)
{
entityCollectionItem.SetColumnValue("SkTitle", trackerData.Title);
entityCollectionItem.SetColumnValue("SkType", trackerData.Type);
entityCollectionItem.SetColumnValue("SkOwner", trackerData.Owner);
entityCollectionItem.SetColumnValue("SkDescription", trackerData.Description);
entityCollectionItem.SetColumnValue("SkEstimate", trackerData.Estimate);
}
entityCollectionItem.Save();
}
foreach (var item in data.Where(x => !foundKeys.Contains(x.Id)))
{
var entity = schema.CreateEntity(_userConnection);
entity.SetDefColumnValues();
entity.SetColumnValue("SkProjectId", _projectId);
entity.SetColumnValue("SkKey", item.Id);
entity.SetColumnValue("SkTitle", item.Title);
entity.SetColumnValue("SkType", item.Type);
entity.SetColumnValue("SkOwner", item.Owner);
entity.SetColumnValue("SkDescription", item.Description);
entity.SetColumnValue("SkEstimate", item.Estimate);
entity.Save();
}
}
/// <summary>
/// Prepare detail esq.
/// </summary>
/// <param name="detail">Custom or simple detail.</param>
/// <param name="detailSuffix">Detail suffix name.</param>
/// <returns><see cref="EntitySchemaQuery"/>prepared esq.</returns>
protected virtual EntitySchemaQuery PrepareDetailEsq(KeyValuePair <string, string> detail, string detailSuffix = "")
{
string parentSchemaName = detail.Value;
EntitySchema detailEntitySchema = _userConnection.EntitySchemaManager.FindInstanceByName(detail.Key);
EntitySchema parentSchema = _userConnection.EntitySchemaManager.FindInstanceByName(parentSchemaName);
if (detailEntitySchema == null || parentSchema == null)
{
return(null);
}
EntitySchemaQuery esq = GetDefEsq(detailEntitySchema);
string idColumn = GetDetailParentColumnName(detail, "{0}.{1}");
var parentColumnAliasWrap = GetColumnAliasWrapper(parentSchema.PrimaryColumn.Name);
esq.AddColumn(idColumn).OrderByAsc().SetForcedQueryColumnValueAlias(parentColumnAliasWrap);
ApplyDetailsModifiedOnFilters(esq, idColumn);
ApplyNextPrimaryColumnFilter(esq, idColumn);
return(esq);
}
/// <summary>
/// Delete files.
/// </summary>
/// <param name="entitySchemaName">EntitySchemaName where the file will be deleted.</param>
/// <param name="ids">id files to delete</param>
/// <param name="useAdminRights">Use rights administration.</param>
public virtual void DeleteFiles(string entitySchemaName, object[] ids, bool useAdminRights = true)
{
var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, entitySchemaName)
{
UseAdminRights = useAdminRights
};
esq.AddAllSchemaColumns();
esq.Filters.Add(
esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Id", ids));
var entityCollection = esq.GetEntityCollection(UserConnection);
for (int i = 0; i < entityCollection.Count; i++)
{
entityCollection[i].UseAdminRights = useAdminRights;
entityCollection[i].Delete();
i--;
}
}
public void DoCopyESM(Guid bookId)
{
var opportunityManager = _userConnection.EntitySchemaManager.GetInstanceByName("NWLibrary");
var bookForCopy = opportunityManager.CreateEntity(_userConnection);
bool exist = bookForCopy.FetchFromDB(new Dictionary <string, object>()
{
{ "Id", bookId }
});
if (exist)
{
var copedBook = opportunityManager.CreateEntity(_userConnection);
copedBook.SetDefColumnValues();
copedBook.SetColumnValue("NWName", bookForCopy.GetColumnValue("NWName"));
copedBook.SetColumnValue("NWNotes", bookForCopy.GetColumnValue("NWNotes"));
copedBook.SetColumnValue("NWDateOfPublication", bookForCopy.GetColumnValue("NWDateOfPublication"));
copedBook.SetColumnValue("NWAuthorId", bookForCopy.GetColumnValue("NWAuthorId"));
copedBook.SetColumnValue("NWisSale", bookForCopy.GetColumnValue("NWisSale"));
copedBook.SetColumnValue("NWTirage", bookForCopy.GetColumnValue("NWTirage"));
copedBook.Save();
var detailData = new EntitySchemaQuery(_userConnection.EntitySchemaManager, "NWAuthorAndBook");
var detailDataColumn = detailData.AddColumn("NWBookToAuthor");
var detailDataColumn1 = detailData.AddColumn("NWAuthorToBook");
var esqFunction = detailData.CreateFilterWithParameters(FilterComparisonType.Equal,
"NWBookToAuthor",
bookId);
detailData.Filters.Add(esqFunction);
var entitydetailDataColumn = detailData.GetEntityCollection(_userConnection);
var opportunityManager1 = _userConnection.EntitySchemaManager.GetInstanceByName("NWAuthorAndBook");
foreach (var entity in entitydetailDataColumn)
{
var detailsDataSet = opportunityManager1.CreateEntity(_userConnection);
detailsDataSet.SetDefColumnValues();
detailsDataSet.SetColumnValue("NWBookToAuthorId", copedBook.GetColumnValue("Id"));
detailsDataSet.SetColumnValue("NWAuthorToBookId", entity.GetTypedColumnValue <Guid>("NWAuthorToBookId"));
detailsDataSet.Save();
}
}
}
private string GetAccountEmail()
{
var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "AccountCommunication");
var number = esq.AddColumn("Number");
esq.AddColumn("CommunicationType");
number.OrderByDesc();
var esqAccountId = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Account", AccountEntity.GetTypedColumnValue <Guid>("Id"));
var esqTypeId = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "CommunicationType", EmailTypeId);
esq.Filters.Add(esqAccountId);
esq.Filters.Add(esqTypeId);
AccountEntityCollection = esq.GetEntityCollection(UserConnection);
if (AccountEntityCollection.Count == 0)
{
return(string.Empty);
}
return(AccountEntityCollection[0].GetTypedColumnValue <string>("Number"));
}
private Dictionary <Guid, string> GetBindedRecords(string schemaName, DataBindingControllerResult result)
{
List <Guid> recordIds = result.ResultMessages?.Keys.ToList();
if (recordIds == null || recordIds.Count == 0)
{
return(null);
}
EntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByName(schemaName);
if (entitySchema.PrimaryDisplayColumn == null)
{
return(null);
}
EntitySchemaQuery bindedRecordsESQ = GetBindedRecordsESQ(entitySchema, recordIds);
EntityCollection collectionRecords = bindedRecordsESQ.GetEntityCollection(UserConnection);
return(collectionRecords.ToDictionary(e => e.PrimaryColumnValue, e => e.PrimaryDisplayColumnValue));
}
private IEnumerable <ForecastColumn> InnerGetColumns(Guid forecastId)
{
var result = new List <ForecastColumn>();
var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, ForecastColumn);
var path = $"[{ForecastIndicator}:Id:Indicator].";
esq.PrimaryQueryColumn.IsAlwaysSelect = true;
esq.AddColumn(Title);
esq.AddColumn(Settings);
esq.AddColumn(Type);
esq.AddColumn("IsHide");
var idColumnName = esq.AddColumn(path + Id).Name;
var nameColumnName = esq.AddColumn(path + Name).Name;
var codeColumnName = esq.AddColumn(path + Code).Name;
var positionColumn = esq.AddColumn(Position);
positionColumn.OrderByAsc();
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Sheet", forecastId));
var collection = esq.GetEntityCollection(UserConnection);
foreach (var item in collection)
{
var name = item.GetTypedColumnValue <string>(Title);
var id = item.GetTypedColumnValue <Guid>(Id);
var code = id.ToString();
if (string.IsNullOrEmpty(name))
{
id = item.GetTypedColumnValue <Guid>(idColumnName);
name = item.GetTypedColumnValue <string>(nameColumnName);
code = item.GetTypedColumnValue <string>(codeColumnName);
}
result.Add(new ForecastColumn {
Id = id,
Name = name,
Code = code,
Settings = item.GetTypedColumnValue <string>(Settings),
Position = item.GetTypedColumnValue <int>(Position),
TypeId = item.GetTypedColumnValue <Guid>($"{Type}Id"),
IsHide = item.GetTypedColumnValue <bool>("IsHide")
});
}
return(result);
}
internal Tuple <DataTable, string> GetAllContactsEsq()
{
const string tableName = "Contact";
EntitySchemaQuery esqResult = new EntitySchemaQuery(UserConnection.EntitySchemaManager, tableName);
esqResult.PrimaryQueryColumn.IsVisible = true;
esqResult.AddColumn("Name");
esqResult.AddColumn("Email");
esqResult.AddColumn("Phone");
Select select = esqResult.GetSelectQuery(UserConnection);
select.BuildParametersAsValue = true;
var entities = esqResult.GetEntityCollection(UserConnection);
return(new Tuple <DataTable, string>(entities.ConvertToDataTable(), select.GetSqlText()));
}
/// <summary>
/// Fills calendar week template.
/// </summary>
/// <param name="calendar">Calendar.</param>
private void FillWeekTemplate(T calendar)
{
var query = new EntitySchemaQuery(_userConnection.EntitySchemaManager, "DayInCalendar");
string dayOfWeekCode = query.AddColumn("DayOfWeek.Code").Name;
string dayOfWeekNonWorking = query.AddColumn("DayType.NonWorking").Name;
string dayType = query.AddColumn("DayType.Id").Name;
var intervalToColumn = query.AddColumn("[WorkingTimeInterval:DayInCalendar].To");
intervalToColumn.OrderByAsc(0);
var intervalFromColumn = query.AddColumn("[WorkingTimeInterval:DayInCalendar].From");
intervalFromColumn.OrderByAsc(1);
string dayOfWeekFromPeriod = intervalFromColumn.Name;
string dayOfWeekToPeriod = intervalToColumn.Name;
query.Filters.Add(
query.CreateFilterWithParameters(FilterComparisonType.Equal, "Calendar", calendar.Id));
EntityCollection collection = query.GetEntityCollection(_userConnection);
foreach (var record in collection)
{
var start = record.GetTypedColumnValue <DateTime>(dayOfWeekFromPeriod);
var end = record.GetTypedColumnValue <DateTime>(dayOfWeekToPeriod);
var dayCode = record.GetTypedColumnValue <string>(dayOfWeekCode);
var dayOfWeek = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), dayCode);
ICalendarDay day = calendar.WeekTemplate.FirstOrDefault(item => item.DayOfWeek == dayOfWeek);
if (day == default(ICalendarDay))
{
var isNonWorking = record.GetTypedColumnValue <bool>(dayOfWeekNonWorking);
var dayTypeUId = record.GetTypedColumnValue <Guid>(dayType);
day = new CalendarDay {
DayOfWeek = dayOfWeek,
IsNonWorking = isNonWorking,
DayTypeUId = dayTypeUId
};
calendar.WeekTemplate.Add(day);
}
if (!day.IsNonWorking)
{
day.WorkingIntervals.Add(new WorkingInterval(start.TimeOfDay, end.TimeOfDay));
}
}
}
private DataObjectSettingsDto GetDataSettingsDto(Guid reportId)
{
var esq = new EntitySchemaQuery(_userConnection.EntitySchemaManager, "SysModuleReport");
var macrosListName = esq.AddColumn("MacrosList").Name;
var sysEntitySchemaUIdColumnName = esq.AddColumn("SysModule.SysModuleEntity.SysEntitySchemaUId").Name;
var sysSchemaCaptionName =
esq.AddColumn("SysModule.SysModuleEntity.[VwSysSchemaInWorkspace:UId:SysEntitySchemaUId].Caption").Name;
var entity = esq.GetEntity(_userConnection, reportId);
if (entity == null)
{
throw new WebFaultException(HttpStatusCode.NotFound);
}
return(new DataObjectSettingsDto {
Caption = entity.GetTypedColumnValue <string>(sysSchemaCaptionName),
MacrosCollection = entity.GetTypedColumnValue <string>(macrosListName),
EntitySchemaUId = entity.GetTypedColumnValue <Guid>(sysEntitySchemaUIdColumnName),
});
}
private IEnumerable <Guid> GetEntitySchemasWithNeedUpdateStructure()
{
var result = new List <Guid>();
var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "VwSysEntitySchemaInWorkspace");
esq.AddAllSchemaColumns();
esq.Filters.LogicalOperation = Terrasoft.Common.LogicalOperationStrict.And;
var needUpdateFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "NeedUpdateStructure", true);
esq.Filters.Add(needUpdateFilter);
var packages = esq.GetEntityCollection(UserConnection);
foreach (var p in packages)
{
var schemaUId = p.GetTypedColumnValue <Guid>("UId");
result.Add(schemaUId);
}
return(result);
}
/// <summary>
/// Add filter by user subscription feed.
/// </summary>
/// <param name="messageQuery">Instance <see cref="EntitySchemaQuery" /></param>
/// <param name="readOptions">Reading options <see cref="EsnReadMessageOptions" />.</param>
protected virtual void AddFeedFilter(EntitySchemaQuery messageQuery, EsnReadMessageOptions readOptions)
{
messageQuery.Filters.Add(messageQuery.CreateIsNullFilter("Parent"));
if (readOptions.OffsetDate != default(DateTime))
{
messageQuery.Filters.Add(
messageQuery.CreateFilterWithParameters(
FilterComparisonType.Less,
GetSortedColumnName(readOptions.SortedBy),
readOptions.OffsetDate
));
}
var feedFilter = new EntitySchemaQueryFilterCollection(messageQuery);
var subscriptionFilter = new EntitySchemaQueryFilterCollection(messageQuery);
subscriptionFilter.LogicalOperation = LogicalOperationStrict.Or;
var userId = UserConnection.CurrentUser.Id;
subscriptionFilter.Add(
messageQuery.CreateFilterWithParameters(
FilterComparisonType.Equal,
"[SocialSubscription:EntityId:EntityId].[SysUserInRole:SysRole:SysAdminUnit].SysUser",
userId
));
subscriptionFilter.Add(
messageQuery.CreateFilterWithParameters(
FilterComparisonType.Equal,
"[SocialSubscription:EntityId:EntityId].SysAdminUnit",
userId
));
feedFilter.Add(subscriptionFilter);
var unsubscriptionFilter = new EntitySchemaQueryFilterCollection(messageQuery);
unsubscriptionFilter.IsNot = true;
unsubscriptionFilter.Add(
messageQuery.CreateFilterWithParameters(
FilterComparisonType.Equal,
"[SocialUnsubscription:EntityId:EntityId].SysAdminUnit",
userId
));
feedFilter.Add(unsubscriptionFilter);
messageQuery.Filters.Add(feedFilter);
}
protected List <OpportunityStageData> GetStagesCollection()
{
var result = new List <OpportunityStageData>();
var stageEsq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "OpportunityStage");
stageEsq.Cache = UserConnection.ApplicationCache.WithLocalCaching(OppInStageCacheGroupName);
stageEsq.CacheItemName = OppInStageCacheGroupItem;
var idColumn = stageEsq.AddColumn("Id");
var numberColumn = stageEsq.AddColumn("Number").OrderByAsc();
var endColumn = stageEsq.AddColumn("End");
var stages = stageEsq.GetEntityCollection(UserConnection);
stages.ForEach(stage => result.Add(new OpportunityStageData {
StageId = stage.GetTypedColumnValue <Guid>(idColumn.Name),
Number = stage.GetTypedColumnValue <int>(numberColumn.Name),
End = stage.GetTypedColumnValue <bool>(endColumn.Name)
}));
return(result);
}
private Select CreateIdsSelect(string serializedFilters, Guid rootObjectUId)
{
EntitySchemaManager entitySchemaManager = _userConnection.EntitySchemaManager;
var jsonFilters
= Json.Deserialize <Nui.ServiceModel.DataContract.Filters>(serializedFilters);
EntitySchema objectSchema = entitySchemaManager.GetInstanceByUId(rootObjectUId);
IEntitySchemaQueryFilterItem esqFilters
= jsonFilters.BuildEsqFilter(objectSchema.UId, _userConnection);
var objectEsq = new EntitySchemaQuery(entitySchemaManager, objectSchema.Name)
{
UseAdminRights = false
};
objectEsq.PrimaryQueryColumn.IsVisible = true;
objectEsq.Filters.Add(esqFilters);
Select idsSelectQuery = objectEsq.GetSelectQuery(_userConnection);
return(idsSelectQuery);
}
public virtual Guid GetSectionName(Guid Id)
{
var cardSchemaUId = Guid.Empty;
var entitySchemaQuery = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "SysModule");
var typeColumn = entitySchemaQuery.AddColumn("SectionSchemaUId");
entitySchemaQuery.Filters.Add(entitySchemaQuery.CreateFilterWithParameters(FilterComparisonType.Equal,
"SysModuleEntity", new object[] { Id }));
var entityCollection = entitySchemaQuery.GetEntityCollection(UserConnection);
if (entityCollection.Count > 0)
{
var entity = entityCollection[0];
cardSchemaUId = entity.GetTypedColumnValue <Guid>(typeColumn.Name);
}
return(cardSchemaUId);
}
/// <summary>
/// Adds length function filter for entity schema query to current filter collection.
/// </summary>
/// <param name="filterCollection">Filter collection, which the created filter will be added to.</param>
/// <param name="schema">Entity schema.</param>
/// <param name="columnName">Name of column, which should be operand for the function.</param>
/// <param name="comparisonType">Type of comparison with function.</param>
/// <param name="value">Value to compare function with.</param>
/// <returns>Created compare filter like "LEN(column_name) comparison_type value".</returns>
public static EntitySchemaQueryFilter AddLengthFilter(this EntitySchemaQueryFilterCollection filterCollection,
EntitySchema schema, string columnName, FilterComparisonType comparisonType, int value)
{
var esq = filterCollection.ParentQuery;
EntitySchemaQueryFunction function = esq.CreateLengthFunction(
EntitySchemaQuery.CreateSchemaColumnExpression(schema, columnName));
var filter = new EntitySchemaQueryFilter(FilterComparisonType.Equal)
{
LeftExpression = new EntitySchemaQueryExpression(function),
ComparisonType = comparisonType
};
filter.RightExpressions.Add(new EntitySchemaQueryExpression(EntitySchemaQueryExpressionType.Parameter)
{
ParameterValue = value
});
filterCollection.Add(filter);
return(filter);
}
/// <summary>
/// Send registration confirmation email.
/// </summary>
/// <param name="userConnection">User connection.</param>
/// <param name="contactId">Contact identifier.</param>
/// <param name="confirmRegistrationUrl">Confirmation registration url.</param>
public static void SendEmail(UserConnection userConnection, Guid contactId, string confirmRegistrationUrl)
{
if (confirmRegistrationUrl.IsNullOrEmpty())
{
string errorMessage = GetLocalizableString(userConnection, "LinkNotExist");
throw new ArgumentNullOrEmptyException(errorMessage, null);
}
string contactEmail = GetContactEmail(userConnection, contactId);
var esq = new EntitySchemaQuery(userConnection.EntitySchemaManager, "EmailTemplate");
esq.AddColumn("Subject");
esq.AddColumn("Body");
esq.AddColumn("IsHtmlBody");
esq.AddColumn("Macros");
Guid registrationEmailTemplateId = GetRegistrationEmailTemplateId(userConnection);
var template = (EmailTemplate)esq.GetEntity(userConnection, registrationEmailTemplateId);
if (template == null)
{
string errorMessage = GetLocalizableString(userConnection, "EmailTemplateNotFound");
throw new ArgumentNullOrEmptyException(errorMessage, null);
}
var body = ReplaceRegistrationUrl(userConnection, contactId, confirmRegistrationUrl, template);
var subject = ReplaceRegistrationUrl(userConnection, contactId, confirmRegistrationUrl, template);
if (userConnection.GetIsFeatureEnabled("EmailIntegrationV2") ||
userConnection.GetIsFeatureEnabled("UseEmailSenderForSelfReg"))
{
SendWithEmailSender(userConnection, contactEmail, body, subject);
}
else
{
var emailMessage = CreateEmailMessage(userConnection, contactEmail, body, subject);
emailMessage.Attachments = GetEmailAttachmentsFromTemplate(registrationEmailTemplateId, userConnection);
var credentials = CreateMailCredentials(userConnection);
var emailClientFactory = GetEmailClientFactory(userConnection);
var emailSender = ClassFactory.Get <IEmailSender>(
new ConstructorArgument("emailClientFactory", emailClientFactory),
new ConstructorArgument("userConnection", userConnection));
emailSender.Send(emailMessage, credentials);
}
}
public decimal GetErSumEsq(string name)
{
EntitySchemaQuery parent = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "ExpenseReport");
parent.AddColumn("Id");
parent.PrimaryQueryColumn.IsVisible = true;
parent.AddColumn("Name");
parent.AddColumn("ReportDate");
parent.AddColumn("Total");
var idFilter = parent.CreateFilterWithParameters(FilterComparisonType.Equal, "Name", name);
parent.Filters.LogicalOperation = LogicalOperationStrict.And;
parent.Filters.Add(idFilter);
EntityCollection records = parent.GetEntityCollection(UserConnection);
DateTime ReportDate = records[0].GetTypedColumnValue <DateTime>("ReportDate");
Guid ParentId = records[0].PrimaryColumnValue;
EntitySchemaQuery children = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "ExpenseReportLines");
children.AddColumn("ExpenseReport");
children.AddColumn("AmountHC");
var parentFilter = children.CreateFilterWithParameters(FilterComparisonType.Equal, "ExpenseReport", ParentId);
children.Filters.LogicalOperation = LogicalOperationStrict.And;
children.Filters.Add(parentFilter);
EntityCollection rows = children.GetEntityCollection(UserConnection);
decimal sum = decimal.Zero;
foreach (Entity row in rows)
{
sum += row.GetTypedColumnValue <decimal>("AmountHC");
}
records[0].SetColumnValue("Total", sum);
records[0].Save();
return(sum);
}
private EntitySchemaQuery GetMacrosESQ(Dictionary <string, string> columnNames)
{
EntitySchemaQuery esq = GetESQWithCommonProperties("Macros");
esq.PrimaryQueryColumn.IsAlwaysSelect = true;
EntitySchemaQueryColumn primaryColumn = esq.PrimaryQueryColumn;
columnNames.Add("Id", primaryColumn.Name);
EntitySchemaQueryColumn captionColumn = esq.AddColumn("Name");
columnNames.Add("Caption", captionColumn.Name);
columnNames.Add("AddCaption", "");
EntitySchemaQueryColumn createdByColumn = esq.AddColumn("CreatedBy");
EntitySchemaQueryColumn commandCodeColumn = esq.AddColumn("=Command.Code");
columnNames.Add("Code", commandCodeColumn.Name);
EntitySchemaQueryColumn columnCaptionColumn = esq.AddColumn(">AdditionalParam.ColumnCaption");
columnNames.Add("ColumnCaption", columnCaptionColumn.Name);
EntitySchemaQueryColumn subjectColumn = esq.AddColumn(">AdditionalParam.SubjectColumnUId");
columnNames.Add("SubjectColumnUId", subjectColumn.Name);
EntitySchemaQueryColumn subjectSchemaColumn = esq.AddColumn("=MainParam.SubjectSchemaUId");
columnNames.Add("SubjectSchemaUId", subjectSchemaColumn.Name);
EntitySchemaQueryColumn mainParamNameColumn = esq.AddColumn("=MainParam.Name");
columnNames.Add("MainParamCaption", mainParamNameColumn.Name);
EntitySchemaQueryColumn typeColumn = esq.AddColumn("=MainParam.=[SysModuleEntity:SysEntitySchemaUId:SubjectSchemaUId].TypeColumnUId");
columnNames.Add("TypeColumnUId", typeColumn.Name);
columnNames.Add("OrderColumn", "");
EntitySchemaQueryColumn mainParamTypeColumn = esq.AddColumn("MainParamType");
columnNames.Add("TypeColumnCode", mainParamTypeColumn.Name);
EntitySchemaQueryColumn isSharedColumn = esq.AddColumn("IsShared");
esq.Filters.Add(esq.CreateIsNotNullFilter("MainParam"));
ApplyCreatedByOrIsSharedFilter(esq);
esq.CacheItemName = "CommandActionCacheItem_Macros";
return(esq);
}
