private Entity CreateEntityFromObject(TEntityData item) { Entity entity = SchemaInstance.CreateEntity(UserConnection); FillEntityFromObject(entity, item); return(entity); }
/// <summary> /// Used to create related to Product Id and PriceList Id ProductPrice entity. /// </summary> /// <param name="basePriceListId">PriceList Id.</param> /// <param name="productId">Product Id.</param> /// <returns>ProductPrice entity.</returns> protected virtual Entity GetNewBaseProductPriceEntity(Guid basePriceListId, Guid productId) { Entity baseProductPrice = _productPriceSchema.CreateEntity(_userConnection); baseProductPrice.SetDefColumnValues(); baseProductPrice.SetColumnValue("Id", Guid.NewGuid()); baseProductPrice.SetColumnValue("PriceListId", basePriceListId); baseProductPrice.SetColumnValue("ProductId", productId); return(baseProductPrice); }
private static void ProcessSheetColumns( UserConnection userConnection, EntitySchema columnSchema, IEnumerable <ForecastColumn> columns) { foreach (ForecastColumn column in columns) { if (!IsFormulaColumn(column)) { continue; } FormulaSetting settings = column.GetColumnSettings <FormulaSetting>(); if (!ShouldMigrateColumn(settings)) { continue; } var sumFormulaItems = settings.UseInSummary ? BuildSumAllFormula(settings) : BuildSUMSelfFormula(column); settings.SummaryValue = sumFormulaItems; var newSettingsJson = JsonConvert.SerializeObject(settings); var entity = columnSchema.CreateEntity(userConnection); entity.FetchFromDB(column.Id); entity.SetColumnValue("Settings", newSettingsJson); entity.Save(false); } }
public virtual void SetDefaultSysMsgUserSettings() { var entitySchemaManager = UserConnection.GetSchemaManager("EntitySchemaManager") as EntitySchemaManager; EntitySchema wSysAccountSchema = entitySchemaManager.GetInstanceByName("WSysAccount"); Entity wSysAccountEntity = wSysAccountSchema.CreateEntity(UserConnection); EntitySchema sysMsgUserSettingsSchema = entitySchemaManager.GetInstanceByName("SysMsgUserSettings"); Entity sysMsgUserSettingsEntity = sysMsgUserSettingsSchema.CreateEntity(UserConnection); sysMsgUserSettingsEntity.SetDefColumnValues(); sysMsgUserSettingsEntity.SetColumnValue("UserId", Entity.PrimaryColumnValue); sysMsgUserSettingsEntity.SetColumnValue("SysMsgLibId", WebitelSymMsgLibId); Dictionary <string, object> connectionParamsDictionary = new Dictionary <string, object>() { { "isWrapUpDisabled", false }, { "debugMode", false }, { "disableCallCentre", false }, { "isAutoLogin", true }, { "useWebitelCti", false }, { "useWebPhone", true }, { "useVideo", false } }; string connectionParams = ServiceStackTextHelper.Serialize(connectionParamsDictionary); sysMsgUserSettingsEntity.SetColumnValue("ConnectionParams", connectionParams); sysMsgUserSettingsEntity.Save(); }
private bool TryGetActivityEntity(Guid activityId, out Entity activityEntity) { EntitySchema activitySchema = UserConnection.EntitySchemaManager.FindInstanceByName(ActivitySchemaName); activityEntity = activitySchema.CreateEntity(UserConnection); return(activityEntity.FetchFromDB(activityId)); }
/// <summary> /// Apply data to database based on EntitySchema name, KeyColumn name and Column mapping. /// Base implementation sorts out data set, map columns with column mapping and set /// columns on entity. /// </summary> /// <param name="entitySchemaName">Entity schema name, for which data applied.</param> /// <param name="keyColumnName">Key column of entity.</param> /// <param name="columnMapping">Columns mapping for DataSet.</param> /// <param name="dataSet">DataSet which applied.</param> public virtual void ApplyData( string entitySchemaName, string keyColumnName, Dictionary <string, string> columnMapping, IEnumerable <Dictionary <string, object> > dataSet) { EntitySchema schema = _userConnection.EntitySchemaManager.GetInstanceByName(entitySchemaName); Entity entity = schema.CreateEntity(_userConnection); try { var mappedKeyColumnName = columnMapping[keyColumnName]; using (var dataSetEnumerator = dataSet.GetEnumerator()) { while (dataSetEnumerator.MoveNext()) { var currentRow = dataSetEnumerator.Current; if (entity.FetchFromDB(currentRow[mappedKeyColumnName])) { SetMappedColumns(currentRow, keyColumnName, columnMapping, entity); entity.Save(); } } } } catch (KeyNotFoundException) { throw new KeyNotFoundException("Column not found in columnMapping dictionary"); } }
/// <summary> /// Get template from db. /// </summary> /// <param name="conditions">Conditions.</param> /// <returns>Template entity.</returns> private Entity GetTemplateFromDb(Dictionary <string, object> conditions) { EntitySchema schema = UserConnection.EntitySchemaManager.FindInstanceByName(SchemaName); Entity template = schema.CreateEntity(UserConnection); return(template.FetchFromDB(conditions) ? template : null); }
protected virtual Entity GetDestinationEntity(EntitySchema destinationSchema) { var entity = destinationSchema.CreateEntity(UserConnection); entity.SetDefColumnValues(); return(entity); }
protected virtual Entity GetEntity(Guid entityId, EntitySchema schema = null) { schema = schema ?? _rootSchema; var linkedEntity = schema.CreateEntity(_userConnection); return(linkedEntity.FetchFromDB(entityId) ? linkedEntity : null); }
/// <summary> /// Removes operations. /// Returns a string that is a JSON object representing execution result. /// </summary> /// <param name="recordIds">Array of operations identity</param> /// <returns>JSON-format string. /// Includes serialized object whith fields: /// Success - the method is successfully executed., /// ExMessage - string with error, if Success = false </returns> public string DeleteAdminOperation(Guid[] recordIds) { bool success = false; string exMessage = string.Empty; try { DBSecurityEngine engine = _userConnection.DBSecurityEngine; engine.CheckCanChangeAdminOperationGrantee(); EntitySchema adminOperationTableSchema = _userConnection.EntitySchemaManager.GetInstanceByName("SysAdminOperation"); Entity adminOperationEntity = adminOperationTableSchema.CreateEntity(_userConnection); foreach (var recordId in recordIds) { if (adminOperationEntity.FetchFromDB("Id", recordId)) { adminOperationEntity.Delete(); } } success = true; } catch (Exception ex) { if (ex is SecurityException) { exMessage = ex.Message; } else { exMessage = new LocalizableString(_userConnection.ResourceStorage, "RightsHelper", "LocalizableStrings.NonSecurityExeption.Value"); } } return(JsonConvert.SerializeObject(new { Success = success, ExMessage = exMessage })); }
/// <summary> /// Returns mailbox synchronization setting for the specific sender email address. /// </summary> /// <param name="senderEmailAddress">Sender email address.</param> /// <returns><see cref="Terrasoft.Core.Entities.Entity"/> instance of <see cref="MailboxSyncSettings"/> entity type.</returns> protected virtual Entity GetMailboxSynSettingEntity(string senderEmailAddress) { EntitySchema entitySchema = _schemaManager.GetInstanceByName("MailboxSyncSettings"); Entity mailbox = entitySchema.CreateEntity(UserConnection); return(mailbox.FetchFromDB("SenderEmailAddress", senderEmailAddress, false) ? mailbox : null); }
/// <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); }
private Entity GetCalendarEntity() { EntitySchema schema = _userConnection.EntitySchemaManager.FindInstanceByName("Calendar"); Entity entity = schema.CreateEntity(_userConnection); return(entity); }
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); }
/// <summary> /// Used to retrieve the Product entity by Id. /// </summary> /// <param name="productId">Product Id.</param> /// <returns>Product entity if it exists.</returns> protected virtual Entity GetProductEntity(Guid productId) { Entity product = _productSchema.CreateEntity(_userConnection); bool isFetched = product.FetchFromDB(productId); return(isFetched ? product : null); }
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(); }
private string GetWebPageForRemoteItem(LocalItem localItem, UserConnection userConnection, Guid contactId) { string result = string.Empty; IEnumerable <SyncEntity> webPageEntities = localItem.Entities["ContactCommunication"].Where(e => e.State != SyncState.New && e.State != SyncState.Deleted && e.Entity.GetTypedColumnValue <Guid>("CommunicationTypeId") == Guid.Parse(CommunicationTypeConsts.WebId)); if (webPageEntities.Any()) { SyncEntity webPageSyncEntity = webPageEntities.First(); result = webPageSyncEntity.Entity.GetTypedColumnValue <string>("Number"); } else { Guid id = TryFindWebPageDetailInLocalStore(userConnection, contactId); if (id == Guid.Empty) { return(result); } EntitySchema schema = userConnection.EntitySchemaManager.GetInstanceByName("ContactCommunication"); var instance = (ContactCommunication)schema.CreateEntity(userConnection); if (instance.FetchFromDB(id, false)) { localItem.AddOrReplace(schema.Name, SyncEntity.CreateNew(instance)); result = instance.Number; } } return(result); }
/// <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); } }
/// <summary> /// Returns <see cref="SyncErrorMessage"/> instance. /// </summary> /// <param name="messageId"><see cref="SyncErrorMessage"/> instance identifier.</param> /// <returns><see cref="SyncErrorMessage"/> instance.</returns> protected Entity GetSyncErrorMessage(Guid messageId) { EntitySchema entitySchema = _schemaManager.GetInstanceByName("SyncErrorMessage"); Entity mailbox = entitySchema.CreateEntity(UserConnection); return(mailbox.FetchFromDB(messageId) ? mailbox : null); }
/// <summary> /// <see cref="ExchangeSyncProvider.OnLocalItemAppliedInRemoteStore"/> /// </summary> public override void OnLocalItemAppliedInRemoteStore(SyncContext context, IRemoteItem remoteItem, LocalItem localItem) { if (!_userConnection.GetIsFeatureEnabled("SyncDeletedAppointments")) { return; } if (remoteItem.Action == SyncAction.Delete && remoteItem.State == SyncState.Deleted) { EntitySchema schema = context.UserConnection.EntitySchemaManager.GetInstanceByName("Activity"); IEnumerable <Guid> entityIds = localItem.Entities["Activity"] .Where(se => se.State != SyncState.Deleted).Select(se => se.EntityId).ToList(); foreach (Guid activityId in entityIds) { Entity activity = schema.CreateEntity(context.UserConnection); if (activity.FetchFromDB(activityId, false)) { localItem.AddOrReplace("Activity", new SyncEntity(activity, SyncState.Modified) { Action = SyncAction.Delete }); } } context.LocalProvider.ApplyChanges(context, localItem); } }
public virtual IFileUploadInfo LoadFile(Guid entitySchemaUId, Guid fileId, BinaryWriter binaryWriter) { EntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByUId(entitySchemaUId); if (!CheckReadFileAccess(entitySchema, fileId)) { Log.Info($"LoadFile: CheckReadFileAccess = false for fileId: ${fileId}"); return(null); } Entity entity = entitySchema.CreateEntity(UserConnection); Select selectData = (new Select(UserConnection) .Column("Name") .Column(Func.DataLength("Data")).As("Size") .Column("Data") .From(entity.SchemaName) .Where("Id") .IsEqual(Column.Parameter(fileId))) as Select; selectData.SpecifyNoLockHints(); using (DBExecutor executor = UserConnection.EnsureDBConnection()) { using (IDataReader reader = selectData.ExecuteReader(executor, CommandBehavior.SequentialAccess)) { if (reader.Read()) { string fileName = reader["Name"].ToString(); int sizeColumnIndex = reader.GetOrdinal("Size"); object sizeValue = reader[sizeColumnIndex]; if (DBNull.Value.Equals(sizeValue)) { Log.Info($"LoadFile: file size is null for fileId: ${fileId}"); return(null); } int size = UserConnection.DBTypeConverter.DBValueToInt(sizeValue); long offset = 0; int bufferOffset = 0; int chunkSize = 524288; byte[] buffer = new byte[chunkSize]; long realBytes = 0; while (offset < size) { Array.Clear(buffer, 0, buffer.Length); realBytes = reader.GetBytes(2, offset, buffer, bufferOffset, chunkSize); if (realBytes <= 0) { break; } offset += realBytes; binaryWriter.Write(buffer, 0, Convert.ToInt32(realBytes)); binaryWriter.Flush(); } var feui = new FileEntityUploadInfo(entitySchema.Name, fileId, fileName); feui.TotalFileLength = size; return(feui); } } } Log.Info($"LoadFile: file not found with Id: ${fileId}"); return(null); }
/// <summary> /// Initialize new instance of <see cref="EmailTemplateLanguageHelper" />. /// </summary> /// <param name="caseId">Case record identifier.</param> /// <param name="userConnection">User connection.</param> public EmailTemplateLanguageHelper(Guid caseId, UserConnection userConnection) { UserConnection = userConnection; EntitySchema caseSchema = UserConnection.EntitySchemaManager.FindInstanceByName("Case"); CaseEntity = caseSchema.CreateEntity(UserConnection) as Case; CaseEntity.FetchFromDB(caseId); }
protected virtual Entity GetSourceEntity(EntitySchema sourceSchema, Dictionary <string, string> validColumnmap, Guid sourceRowId) { var entity = sourceSchema.CreateEntity(UserConnection); IEnumerable <string> columnsToFetch = validColumnmap.Values.Distinct(); entity.FetchFromDB(sourceSchema.GetPrimaryColumnName(), sourceRowId, columnsToFetch); return(entity); }
/// <summary> /// Initialize new instance of <see cref="EmailTemplateCommLangHandler" />. /// </summary> /// <param name="caseId">Case record identifier.</param> /// <param name="userConnection">User connection.</param> protected EmailTemplateCommLangHandler(Guid caseId, UserConnection userConnection) { UserConnection = userConnection; EntitySchema caseSchema = UserConnection.EntitySchemaManager.FindInstanceByName("Case"); CaseEntity = caseSchema.CreateEntity(UserConnection) as Case; CaseEntity.FetchFromDB(caseId); }
/// <summary> /// Returns empty address entity. /// </summary> /// <returns>Empty address <see cref="Entity"/>.</returns> protected virtual Entity GetEmptyAddressEntity() { EntitySchema schema = UserConnection.EntitySchemaManager.GetInstanceByName(AddressEntity.SchemaName); Entity entity = schema.CreateEntity(UserConnection); entity.SetDefColumnValues(); return(entity); }
/// <summary> /// Get entity from DB by id /// </summary> /// <param name="elementId"></param> /// <returns>Return entity</returns> private Entity GetEntity(Guid elementId) { EntitySchema schema = _userConnection.EntitySchemaManager.GetInstanceByName(_entitySchemaName); Entity entity = schema.CreateEntity(_userConnection); entity.FetchFromDB(elementId); return(entity); }
private Entity GetEntity() { EntitySchema schema = UserConnection.EntitySchemaManager .FindInstanceByUId(ForecastSheet.ForecastEntityInCellUId); Entity entity = schema.CreateEntity(UserConnection); return(entity); }
/// <summary> /// Fetch <see cref="MailboxSyncSettings"/> instance by <see cref="MailboxSyncSettings.SenderEmailAddress"/> column value, /// filtered using <paramref name="senderEmailAddress"/>. /// <paramref name="settings"/> would be set with fetched instance. /// </summary> /// <param name="senderEmailAddress">Sender email address filter value.</param> /// <param name="userConnection"><see cref="UserConnection"/> instance.</param> /// <param name="settings">Fetched <see cref="MailboxSyncSettings"/> instance.</param> /// <returns><c>True</c> if mailbox successfully fetched from database, <c>false</c> otherwise.</returns> private bool FetchSettingsEntity(string senderEmailAddress, UserConnection userConnection, out Entity settings) { EntitySchema schema = userConnection.EntitySchemaManager.GetInstanceByName("MailboxSyncSettings"); Entity mailboxSyncSettings = schema.CreateEntity(userConnection); settings = mailboxSyncSettings; return(mailboxSyncSettings.FetchFromDB("SenderEmailAddress", senderEmailAddress)); }
/// <summary> /// Fills exchange companies to bpmonline account dictionary. /// </summary> /// <param name="context"><see cref="SyncContext"/> instance.</param> /// <param name="exchangeCompanies">Exchange company names.</param> private void FillAccountsMap(SyncContext context, List <string> exchangeCompanies) { if (exchangeCompanies == null || !exchangeCompanies.Any()) { return; } if (UserSettings.LinkContactToAccountType == ExchangeConsts.NeverLinkContactToAccountId) { return; } IEnumerable <string> distinctExchangeCompanies = exchangeCompanies.Distinct(); int index = 0; while (index < distinctExchangeCompanies.Count()) { IEnumerable <string> paramsValue = distinctExchangeCompanies.Skip(index).Take(EsqParamsCount); index += EsqParamsCount; var accountsEsq = new EntitySchemaQuery(context.UserConnection.EntitySchemaManager, "Account"); accountsEsq.PrimaryQueryColumn.IsAlwaysSelect = true; accountsEsq.AddColumn("Name"); accountsEsq.Filters.Add(accountsEsq.CreateFilterWithParameters(FilterComparisonType.Equal, false, "Name", paramsValue.ToArray())); EntityCollection accounts = accountsEsq.GetEntityCollection(context.UserConnection); if (accounts.Any()) { foreach (Entity account in accounts) { var accountName = account.GetTypedColumnValue <string>("Name"); if (!AccountsMap.ContainsKey(accountName)) { AccountsMap[accountName] = account.PrimaryColumnValue; } } } } IEnumerable <string> notFoundCompanies = from company in exchangeCompanies where AccountsMap.All(am => am.Key != company) select company; var companies = notFoundCompanies as IList <string> ?? notFoundCompanies.ToList(); if (!companies.Any() || UserSettings.LinkContactToAccountType != ExchangeConsts.AllwaysLinkContactToAccountId) { return; } foreach (string company in companies) { EntitySchema accountSchema = context.UserConnection.EntitySchemaManager.FindInstanceByName("Account"); Entity account = accountSchema.CreateEntity(context.UserConnection); account.SetDefColumnValues(); account.SetColumnValue("Name", company); AccountsMap[company] = account.GetTypedColumnValue <Guid>("Id"); account.Save(false); } }
protected virtual void CreateContactEntity(Guid contactId, FormFieldsData contactNameField) { EntitySchema contactSchema = _userConnection.EntitySchemaManager.GetInstanceByName(ContactSchemaName); Entity contact = contactSchema.CreateEntity(_userConnection); contact.SetDefColumnValues(); contact.SetColumnValue("Id", contactId); contact.SetColumnValue("Name", contactNameField.value); contact.Save(false); }