public void GetIdPath_Returns_In_Correct_Order_For_Schemas()
{
//mock hive
IReadonlyEntityRepositoryGroup<IContentStore> readonlyEntitySession;
IReadonlySchemaRepositoryGroup<IContentStore> readonlySchemaSession;
IEntityRepositoryGroup<IContentStore> entityRepository;
ISchemaRepositoryGroup<IContentStore> schemaSession;
var hive = MockHiveManager.GetManager().MockContentStore(out readonlyEntitySession, out readonlySchemaSession, out entityRepository, out schemaSession);
var schema = new EntitySchema { Id = new HiveId(100) };
schemaSession.Get<EntitySchema>(Arg.Any<bool>(), Arg.Any<HiveId[]>()).Returns(new[] { schema });
schemaSession.GetAncestorRelations(new HiveId(100), FixedRelationTypes.DefaultRelationType)
.Returns(new[]
{
new Relation(FixedRelationTypes.DefaultRelationType, new EntitySchema{Id = new HiveId(99)}, schema),
new Relation(FixedRelationTypes.DefaultRelationType, new EntitySchema{Id = new HiveId(98)}, new EntitySchema{Id = new HiveId(99)}),
new Relation(FixedRelationTypes.DefaultRelationType, new EntitySchema{Id = new HiveId(97)}, new EntitySchema{Id = new HiveId(98)}),
});
using (var uow = hive.OpenWriter<IContentStore>())
{
var path = uow.Repositories.Schemas.GetEntityPath<EntitySchema>(new HiveId(100), FixedRelationTypes.DefaultRelationType);
Assert.AreEqual(new HiveId(97), path.ElementAt(0));
Assert.AreEqual(new HiveId(98), path.ElementAt(1));
Assert.AreEqual(new HiveId(99), path.ElementAt(2));
Assert.AreEqual(new HiveId(100), path.ElementAt(3));
}
}
public static string GetEntityName(EntitySchema entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
return(ToHuman(new EntityName(entity.Name).Name));
}
public static List <Filter> DeserializeFilters(EntitySchema entity, XElement element)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (element == null)
{
throw new ArgumentNullException(nameof(element));
}
var result = new List <Filter>();
if (element.Name.LocalName != "filters")
{
throw new InvalidOperationException();
}
foreach (var filter in element.Elements(element.Name.Namespace + "filter"))
{
string name = filter.Attribute("name").Value;
string type = filter.Attribute("type").Value;
var valueElement = filter.Element(element.Name.Namespace + "value");
object value = null;
if (valueElement != null)
{
string valueType = valueElement.Attribute("type").Value;
switch (valueType)
{
case "string":
value = valueElement.Value;
break;
case "decimal":
value = XmlConvert.ToDecimal(valueElement.Value);
break;
case "datetime":
value = XmlConvert.ToDateTime(valueElement.Value, XmlDateTimeSerializationMode.Local);
break;
default:
throw new InvalidOperationException("Unsupported filter type");
}
}
var member = entity.Members[name] as EntityPhysicalField;
if (member != null)
{
result.Add(new Filter(member, (FilterType)Enum.Parse(typeof(FilterType), type, true), value));
}
}
return(result);
}
/// <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);
}
}
/// <summary>
/// Get language identifier from mailbox by that set in system setting.
/// </summary>
/// <param name="supportServiceEmail">System setting for incident registration value.</param>
/// <returns>Language identifier.</returns>
private Guid GetLanguageId(string supportServiceEmail)
{
EntitySchema mailboxSyncSettingsSchema =
UserConnection.EntitySchemaManager.FindInstanceByName("MailboxSyncSettings");
Entity entity = mailboxSyncSettingsSchema.CreateEntity(UserConnection);
return(entity.FetchFromDB("SenderEmailAddress", supportServiceEmail)
? entity.GetTypedColumnValue <Guid>("MessageLanguageId")
: Guid.Empty);
}
public string GetShortCurrencyCode(Guid CurrencyId)
{
EntitySchema currencySchema = UserConnection.EntitySchemaManager.GetInstanceByName("Currency");
Entity currency = currencySchema.CreateEntity(UserConnection);
currency.FetchFromDB(CurrencyId);
var shortCode = currency.GetTypedColumnValue <string>("ShortName");
return(shortCode);
}
public EntitySchema MapAttributeSchemaDefinition(AttributeSchemaDefinition attributeSchemaDefinition, AbstractLookupHelper lookupHelper, AbstractMappingEngine masterMapper)
{
//TODO
//- Map AttributeGroupDefinitions - how to track changes?
//- Add DateModified to Rdbms model
var mapped = new EntitySchema();
MapAttributeSchemaDefinition(attributeSchemaDefinition, mapped, lookupHelper, masterMapper);
return(mapped);
}
public InheritedAttributeGroup(AttributeGroup attributeGroup, EntitySchema schema)
: base(attributeGroup.Alias, attributeGroup.Name, attributeGroup.Ordinal)
{
Id = attributeGroup.Id;
UtcCreated = attributeGroup.UtcCreated;
UtcModified = attributeGroup.UtcModified;
UtcStatusChanged = attributeGroup.UtcStatusChanged;
Schema = schema;
}
/// <summary>
/// <inheritdoc cref="IFileImportHeadersProcessorFactory"/>
/// </summary>
public IFileImportHeadersCreator GetProcessor(UserConnection userConnection, EntitySchema rootSchema)
{
var userConnectionArgs = new ConstructorArgument("userConnection", userConnection);
if (rootSchema.Name == "SysTranslation")
{
return(ClassFactory.Get <SysTranslationFileImportHeadersProcessor>(userConnectionArgs));
}
return(ClassFactory.Get <DefaultFileImportHeadersProcessor>(userConnectionArgs));
}
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);
}
private static string ResolveSourceColumnType(EntitySchema schema, string columnName)
{
var propertyType = schema?.Columns.FirstOrDefault(col => col.ColumnValueName == columnName)?.ValueType;
if (!(propertyType is null) && _typeMapping.TryGetValue(propertyType, out string typeMapping))
{
return(typeMapping);
}
return(UnknownType);
}
protected virtual string GetReferencedColumnValueName()
{
Guid columnUId = ColumnSetting.RefColumnId;
EntitySchema entitySchema = UserConnection.EntitySchemaManager.FindInstanceByName(CalculatedEntityName);
string columnName = columnUId != null
? entitySchema.Columns.FirstOrDefault(c => c.UId == columnUId)?.ColumnValueName
: string.Empty;
return(columnName);
}
public SlicedEntityMetadata([NotNull] string name, [NotNull] EntitySchema schema,
[NotNull] IEnumerable <EntityAssociation> associations, [NotNull] ConnectorParameters connectorParameters, ApplicationSchemaDefinition appSchema,
IEnumerable <SlicedEntityMetadata> innerMetadatas, int?fetchLimit = 300, SlicedEntityMetadata unionSchema = null)
: base(name, schema, associations, connectorParameters)
{
_appSchema = appSchema;
_fetchLimit = fetchLimit;
_innerMetadatas.AddRange(innerMetadatas);
_unionSchema = unionSchema;
}
/// <summary>
/// Returns allowed activity results.
/// </summary>
/// <param name="userConnection">User connection.</param>
/// <param name="activityId">ID of the activity.</param>
/// <returns>Allowed values of the activity result.</returns>
public static string GetAllowedActivityResults(UserConnection userConnection, Guid activityId)
{
var select = (Select) new Select(userConnection)
.Column("AllowedResult")
.From("Activity")
.Where("Id").IsEqual(Column.Parameter(activityId));
var allowedResult = select.ExecuteScalar <string>();
if (string.IsNullOrEmpty(allowedResult))
{
return("[]");
}
EntitySchemaManager entitySchemaManager = userConnection.EntitySchemaManager;
EntitySchema entitySchema = entitySchemaManager.GetInstanceByName("ActivityResult");
var esq = new EntitySchemaQuery(entitySchemaManager, entitySchema.Name)
{
UseAdminRights = false
};
esq.PrimaryQueryColumn.IsAlwaysSelect = true;
string columnName = entitySchema.GetPrimaryDisplayColumnName();
esq.AddColumn(columnName);
esq.AddColumn("Category");
EntitySchemaQueryFilterCollection filters = esq.Filters;
var allowedResultIds = ServiceStackTextHelper.Deserialize <string[]>(allowedResult);
var columnParameters = new object[allowedResultIds.Length];
for (int i = 0; i < allowedResultIds.Length; i++)
{
var resultId = new Guid(allowedResultIds[i]);
columnParameters[i] = resultId;
}
filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Id", columnParameters));
EntityCollection entityCollection = esq.GetEntityCollection(userConnection);
bool isFirstItem = true;
var sb = new StringBuilder("[");
foreach (Entity entity in entityCollection)
{
if (!isFirstItem)
{
sb.Append(",");
}
else
{
isFirstItem = false;
}
sb.AppendFormat("{{\"resultId\":\"{0}\",\"caption\":\"{1}\",\"categoryId\":\"{2}\"}}",
entity.GetTypedColumnValue <Guid>("Id"), entity.GetTypedColumnValue <string>(columnName),
entity.GetTypedColumnValue <Guid>("CategoryId"));
}
sb.Append("]");
return(sb.ToString());
}
/// <summary>
/// Сохранение настройки колонок
/// </summary>
/// <param name="profileData"></param>
public void SaveCustomProfiles(MspProfileData profileData)
{
string profileValue = (profileData.IsTiled) ? ParseTiledProfile(profileData.ProfileValue) : ParseListedProfile(profileData.ProfileValue);
EntitySchema profileSchema = _userConnection.EntitySchemaManager.GetInstanceByName("MspCustomProfile");
var entity = profileSchema.CreateEntity(_userConnection);
entity.FetchFromDB(profileData.ProfileSettingsId);
entity.SetColumnValue("MspIsTiled", profileData.IsTiled);
entity.SetColumnValue("MspValue", profileValue);
entity.Save(false);
}
/// <summary>
/// ####### ######### ###### # SysAdminUnitGrantedRight.
/// </summary>
/// <param name="selectedRecordId">######### ######.</param>
private void DeleteSysAdminUnitGrantedRight(object selectedRecordId)
{
UserConnection.DBSecurityEngine.CheckCanExecuteOperation("CanChangeAdminUnitGrantedRight");
EntitySchema tableSchema = UserConnection.EntitySchemaManager.GetInstanceByName("SysAdminUnitGrantedRight");
Entity entity = tableSchema.CreateEntity(UserConnection);
if (entity.FetchFromDB(selectedRecordId))
{
entity.Delete();
}
}
/// <summary>
/// ######### ##### ###### # # ####### SysAdminUnitGrantedRight.
/// </summary>
/// <param name="granteeSysAdminUnitId">######## ####### "######## #####".</param>
/// <param name="grantorSysAdminUnitId">######## ####### "####### #####".</param>
private void InsertSysAdminUnitGrantedRight(object granteeSysAdminUnitId, object grantorSysAdminUnitId)
{
UserConnection.DBSecurityEngine.CheckCanExecuteOperation("CanChangeAdminUnitGrantedRight");
EntitySchema tableSchema = UserConnection.EntitySchemaManager.GetInstanceByName("SysAdminUnitGrantedRight");
Entity entity = tableSchema.CreateEntity(UserConnection);
entity.SetDefColumnValues();
entity.SetColumnValue("GranteeSysAdminUnitId", granteeSysAdminUnitId);
entity.SetColumnValue("GrantorSysAdminUnitId", grantorSysAdminUnitId);
entity.Save();
}
protected virtual Entity CreateLinkedEntity(EntitySchema linkedSchema, EntitySchemaColumn linkedColumn)
{
Entity linkedEntity = linkedSchema.CreateEntity(_userConnection);
linkedEntity.SetDefColumnValues();
Guid idValue = GetNewLinkedEntityId(_formFields, linkedColumn);
linkedEntity.SetColumnValue("Id", idValue);
_rootEntity.SetColumnValue(linkedColumn, idValue);
return(linkedEntity);
}
/// <summary>
/// Indicates if lead in final status.
/// </summary>
/// <param name="leadStatusId">Lead status identifier.</param>
/// <returns>True if status is final.</returns>
public bool IsLeadInFinalStatus(Guid leadStatusId)
{
EntitySchema qualifyStatusSchema = _userConnection.EntitySchemaManager.GetInstanceByName("QualifyStatus");
Entity qualifyStatusEntity = qualifyStatusSchema.CreateEntity(_userConnection);
qualifyStatusEntity.PrimaryColumnValue = leadStatusId;
qualifyStatusEntity.FetchFromDB(new List <string> {
"IsFinal"
}, false);
return(qualifyStatusEntity.GetTypedColumnValue <bool>("IsFinal"));
}
internal override void applyMembers <A>(WSDynamicResponse <A> response)
{
try
{
if (EntitySchema != null)
{
EntitySchema.apply(response);
}
}
catch (Exception e) { Func.RegError(GetType(), e, ref response.iostatus); }
}
/// <summary>
/// Deletes user
/// </summary>
/// <param name="userId">user Id</param>
private void DeletePortalUser(Guid userId)
{
CheckCanChangeUserData(userId);
EntitySchema adminUnitSchema = SystemUserConnection.EntitySchemaManager.GetInstanceByName("VwSysAdminUnit");
Entity adminUnitEntity = adminUnitSchema.CreateEntity(SystemUserConnection);
if (adminUnitEntity.FetchFromDB(userId))
{
adminUnitEntity.Delete();
}
}
/// <summary>
/// Creates a new <see cref="Terrasoft.Configuration.ContactSyncSettings"/> record
/// for the specific <see cref="Terrasoft.Configuration.MailboxSyncSettings"/> identifier.
/// </summary>
/// <param name="mailboxId"><see cref="Terrasoft.Configuration.MailboxSyncSettings"/> identifier.</param>
private void CreateNewContactSyncSettings(Guid mailboxId)
{
EntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByName("ContactSyncSettings");
Entity contact = entitySchema.CreateEntity(UserConnection);
contact.SetDefColumnValues();
contact.SetColumnValue("MailboxSyncSettingsId", mailboxId);
contact.SetColumnValue("ExportContactsAll", true);
contact.SetColumnValue("ImportContactsAll", true);
contact.Save();
}
protected virtual ImportParameters GetImportParams(EntitySchema entitySchema)
{
var importParameters = new ImportParameters();
importParameters.Entities = new List <ImportEntity>();
var entity = new ImportEntity();
importParameters.Entities.Add(entity);
importParameters.RootSchemaUId = entitySchema.UId;
return(importParameters);
}
private bool GetIsRecordLevelRightAllowed(EntitySchema entitySchema,
Guid entityId, SchemaRecordRightLevels inspectRightLevel)
{
if (!_userConnection.DBSecurityEngine.GetIsEntitySchemaAdministratedByRecords(entitySchema))
{
return(true);
}
var rightLevel = _userConnection.DBSecurityEngine.GetEntitySchemaRecordRightLevel(entitySchema, entityId);
return((rightLevel & inspectRightLevel) == inspectRightLevel);
}
private EntityCollection FindEntityByPrimaryDisplay(EntitySchema entitySchema, string primaryDisplayValue)
{
var ESQ = new EntitySchemaQuery(entitySchema);
ESQ.PrimaryQueryColumn.IsAlwaysSelect = true;
ESQ.AddColumn(entitySchema.PrimaryDisplayColumn.Name);
ESQ.Filters.Add(ESQ.CreateFilterWithParameters(FilterComparisonType.Equal, entitySchema.PrimaryDisplayColumn.Name, primaryDisplayValue));
var entityCollection = ESQ.GetEntityCollection(UserConnection);
return(entityCollection);
}
private string GetEntityConnectionColumnName(EntitySchema activitySchema, EntityActivitiesOwnerInfo entityOwnerInfo)
{
string entityPrimaryColumnName = activitySchema.Columns
.FirstOrDefault(column =>
column.IsLookupType &&
!column.UsageType.Equals(EntitySchemaColumnUsageType.Advanced) &&
column.ReferenceSchema.Name == entityOwnerInfo.EntitySchemaName &&
column.ColumnValueName.Contains(entityOwnerInfo.EntitySchemaName))?.ColumnValueName;
return(entityPrimaryColumnName);
}
private Entity CreateNewEnrichedData(TextEntities emailEntities)
{
EntitySchema enrchEmailDataSchema = _userConnection.EntitySchemaManager.GetInstanceByName("EnrchEmailData");
Entity newEnrichedData = enrchEmailDataSchema.CreateEntity(_userConnection);
newEnrichedData.SetDefColumnValues();
newEnrichedData.SetColumnValue("JsonData", JsonConvert.SerializeObject(emailEntities));
newEnrichedData.SetColumnValue("Hash", emailEntities.GetHash());
newEnrichedData.Save();
return(newEnrichedData);
}
public bool Execute(string sourceSchemaName, params Guid[] records)
{
sourceSchemaName.CheckArgumentNullOrWhiteSpace(nameof(sourceSchemaName));
records.CheckIsNotEmpty(nameof(records));
CheckUserPermissions(sourceSchemaName, records);
EntitySchema folderEntitySchema = _userConnection.EntitySchemaManager.GetInstanceByName(sourceSchemaName);
bool result = DeleteFromFavoriteFolder(folderEntitySchema.UId, records);
DeleteFolders(folderEntitySchema, records);
return(result);
}
private Entity GetTemplateFile(Guid fileId)
{
EntitySchema entitySchema = _userConnection.EntitySchemaManager.GetInstanceByName("SysReportTemplate");
Entity entity = entitySchema.CreateEntity(_userConnection);
if (!entity.FetchFromDB(fileId))
{
throw new ItemNotFoundException(_userConnection, fileId.ToString(), "WordReportingDesignWorker");
}
return(entity);
}
/// <summary>
/// Returns files <see cref="EntityCollection"/> for copying.
/// </summary>
/// <param name="sourceMasterSchemaName">Source master schema name.</param>
/// <param name="sourceMasterRecordId">Source master record uniqueidentifier.</param>
/// <param name="primaryColumnName">Generated <see cref="EntitySchemaQuery"/> primary column name.</param>
/// <returns>Files <see cref="EntityCollection"/>.</returns>
protected virtual EntityCollection GetFilesToCopy(string sourceMasterSchemaName, Guid sourceMasterRecordId,
out string primaryColumnName)
{
EntitySchema sourceFileSchema = GetFileSchema(sourceMasterSchemaName);
var filesEsq = new EntitySchemaQuery(sourceFileSchema);
primaryColumnName = filesEsq.AddColumn(filesEsq.RootSchema.GetPrimaryColumnName()).Name;
filesEsq.Filters.Add(filesEsq
.CreateFilterWithParameters(FilterComparisonType.Equal, sourceMasterSchemaName, sourceMasterRecordId));
return(filesEsq.GetEntityCollection(UserConnection));
}
private Entity GetReportEntity(Guid reportId)
{
EntitySchema entitySchema = _userConnection.EntitySchemaManager.GetInstanceByName("SysModuleReport");
Entity entity = entitySchema.CreateEntity(_userConnection);
if (!entity.FetchFromDB(reportId))
{
throw new ItemNotFoundException(_userConnection, reportId.ToString(), "WordReportingDesignWorker");
}
return(entity);
}
/// <summary>
/// Returns <see cref="SyncErrorMessage"/> instance filtered by <paramref name="errorCode"/>.z
/// </summary>
/// <param name="errorCode"><see cref="SyncErrorMessage.Code"/> column value.</param>
/// <returns><see cref="SyncErrorMessage"/> instance.</returns>
protected Entity GetSyncErrorMessageByCode(Guid errorCodeId)
{
EntitySchema syncErrorMessageSchema = _schemaManager.GetInstanceByName("SyncErrorMessage");
Entity syncErrorMessage = syncErrorMessageSchema.CreateEntity(UserConnection);
if (syncErrorMessage.FetchFromDB(errorCodeId, false))
{
return(syncErrorMessage);
}
return(null);
}
public CompositeEntitySchema(EntitySchema schema, IEnumerable<EntitySchema> ancestorSchemas, bool copyRelationProxiesFromSchema = false)
: base(schema.Alias, schema.Name)
{
//TODO: Need to move this into a mapper, but not currently one available at the right level
Id = schema.Id;
SchemaType = SchemaType;
AttributeGroups.AddRange(schema.AttributeGroups);
AttributeDefinitions.AddRange(schema.AttributeDefinitions);
UtcCreated = schema.UtcCreated;
UtcModified = schema.UtcModified;
UtcStatusChanged = schema.UtcStatusChanged;
var inheritedDefsDict = new Dictionary<string, InheritedAttributeDefinition>();
var inheritedDefs = ancestorSchemas
.SelectMany(entitySchema => entitySchema.AttributeDefinitions.Select(definition => new InheritedAttributeDefinition(definition, entitySchema))).ToArray();
foreach (var def in inheritedDefs)
{
if (!inheritedDefsDict.ContainsKey(def.Alias))
inheritedDefsDict.Add(def.Alias, def);
}
InheritedAttributeDefinitions = new EntityCollection<InheritedAttributeDefinition>(inheritedDefsDict.Values);
// Need to only show the inherited groups that are exposed by the filtered inherited attribute definitions, but also include empty
// groups so that they have a chance to have some definitions added
var allLinkedGroups = ancestorSchemas.SelectMany(x => x.AttributeDefinitions.Select(y => new InheritedAttributeGroup(y.AttributeGroup, x)));
var allKnownGroups = ancestorSchemas.SelectMany(x => x.AttributeGroups.Select(y => new InheritedAttributeGroup(y, x)));
var unlinkedGroups = allKnownGroups.Except(allLinkedGroups);
var inheritedGroups =
InheritedAttributeDefinitions.Select(x => new InheritedAttributeGroup(x.AttributeGroup, x.Schema)).Union
(unlinkedGroups);
InheritedAttributeGroups = new EntityCollection<InheritedAttributeGroup>(inheritedGroups);
RelationProxies.LazyLoadDelegate = schema.RelationProxies.LazyLoadDelegate;
XmlConfiguration = schema.XmlConfiguration;
if (copyRelationProxiesFromSchema)
{
foreach (var proxies in schema.RelationProxies.GetManualParentProxies())
{
RelationProxies.EnlistParent(proxies.Item.Source, proxies.Item.Type, proxies.Item.Ordinal, proxies.Item.MetaData.ToArray());
}
foreach (var proxies in schema.RelationProxies.GetManualChildProxies())
{
RelationProxies.EnlistParent(proxies.Item.Source, proxies.Item.Type, proxies.Item.Ordinal, proxies.Item.MetaData.ToArray());
}
}
}
public InheritedAttributeDefinition(AttributeDefinition attributeDefinition, EntitySchema schema)
: base(attributeDefinition.Alias, attributeDefinition.Name)
{
Id = attributeDefinition.Id;
Description = attributeDefinition.Description;
AttributeType = attributeDefinition.AttributeType;
Ordinal = attributeDefinition.Ordinal;
RenderTypeProviderConfigOverride = attributeDefinition.RenderTypeProviderConfigOverride;
AttributeGroup = attributeDefinition.AttributeGroup != null ? new InheritedAttributeGroup(attributeDefinition.AttributeGroup, schema) : null;
UtcCreated = attributeDefinition.UtcCreated;
UtcModified = attributeDefinition.UtcModified;
UtcStatusChanged = attributeDefinition.UtcStatusChanged;
Schema = schema;
}
public void WhenSavingEntitySchemaWithGroups_GroupIdsGetPopulated()
{
var group1 = new AttributeGroup("group1", "Group 1", 0);
var schema = new EntitySchema("schema");
schema.AttributeGroups.Add(group1);
using (var writer = ProviderSetup.UnitFactory.Create())
{
writer.EntityRepository.Schemas.AddOrUpdate(schema);
writer.Complete();
}
Assert.False(schema.Id.IsNullValueOrEmpty());
Assert.False(group1.Id.IsNullValueOrEmpty());
}
public EntitySchemaViewModel(EntitySchemaCollection srcCollection, EntitySchema schema)
{
Attributes = new ObservableCollection<ItemInfoKVP>();
this.Schema = schema;
this.EntityType = schema.EntityType;
this.Category = schema.Category;
this.SupportedEntities = new ObservableCollection<string>();
foreach ( var se in schema.SupportedEntityTypes )
{
SupportedEntities.Add(se);
}
foreach ( var kvp in schema.Attributes )
{
ItemInfoKVP item = new ItemInfoKVP() { Key = kvp.Key, Value = kvp.Value};
Attributes.Add(item);
item.OnItemEndEdit += item_OnItemEndEdit;
item.PropertyChanged += item_PropertyChanged;
item.PropertyChanging += item_PropertyChanging;
}
Attributes.CollectionChanged += Attributes_CollectionChanged;
}
/// <summary>
/// Creates the new content entity.
/// </summary>
/// <param name="docTypeData">The doc type data.</param>
/// <param name="name">The name.</param>
/// <param name="parentId">The parent id.</param>
/// <returns></returns>
private MediaEditorModel CreateNewContentEntity(EntitySchema docTypeData, string name, HiveId parentId)
{
Mandate.ParameterNotNull(docTypeData, "docTypeData");
Mandate.ParameterNotEmpty(parentId, "parentId");
//get doc type model
var docType = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map<EntitySchema, DocumentTypeEditorModel>(docTypeData);
//map (create) content model from doc type model
var contentModel = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map<DocumentTypeEditorModel, MediaEditorModel>(docType);
contentModel.ParentId = parentId;
contentModel.Name = name;
return contentModel;
}
public static EntitySchema CreateEntitySchema(string alias, string name, params AttributeDefinition[] attributeDefinitions)
{
var def = new EntitySchema();
def.Setup(alias, name);
def.AttributeDefinitions.AddRange(attributeDefinitions);
return def;
}
/// <summary>
/// TEMPORARY method to install all data required for dev data set excluding all of the core data
/// </summary>
/// <param name="manager"></param>
/// <param name="framework"></param>
internal void InstallDevDataset(IHiveManager manager, IFrameworkContext framework)
{
//LogHelper.Error<PugpigInstallTask>(
// string.Format("Inside the dataset class"), new Exception());
//a list of all the schemas we've added
var schemas = new List<EntitySchema>();
using (var writer = manager.OpenWriter<IContentStore>())
{
//create all of the document type's and their associated tabs first
//foreach (var d in _devDataSet.ContentData.Select(x => x.DocumentType).DistinctBy(x => x.Id))
foreach (var d in DocTypes)
{
var schema = new EntitySchema(d.Alias, d.Name);
schema.Id = d.Id;
schema.AttributeGroups.AddRange(
framework.TypeMappers.Map<IEnumerable<Tab>, IEnumerable<AttributeGroup>>(
d.DefinedTabs));
writer.Repositories.Schemas.AddOrUpdate(schema);
schemas.Add(schema);
foreach (var parentId in d.InheritFrom.Where(x => x.Selected).Select(x => HiveId.Parse(x.Value)))
writer.Repositories.AddRelation(new Relation(FixedRelationTypes.DefaultRelationType, parentId, d.Id));
}
writer.Complete();
}
using (var writer = manager.OpenWriter<IContentStore>())
{
//now we can hopefully just map the schema and re-save it so it maps all properties
//foreach (var d in _devDataSet.ContentData.Select(x => x.DocumentType).DistinctBy(x => x.Id))
IEnumerable<TypedEntity> typedEntities = writer.Repositories.GetAll<TypedEntity>();
foreach (var d in DocTypes)
{
var schema = framework.TypeMappers.Map<DocumentTypeEditorModel, EntitySchema>(d);
writer.Repositories.Schemas.AddOrUpdate(schema);
}
writer.Complete();
}
using (var writer = manager.OpenWriter<IContentStore>())
{
//now just map the entire content entities and persist them, since the attribution definitions and attribution
//groups are created these should just map up to the entities in the database.
var mappedCollection = framework
.TypeMappers.Map<IEnumerable<ContentEditorModel>, IEnumerable<Revision<TypedEntity>>>(ContentData)
.ToArray();
mappedCollection.ForEach(x => x.MetaData.StatusType = FixedStatusTypes.Published);
//var allAttribTypes = AllAttribTypes(mappedCollection);
writer.Repositories.Revisions.AddOrUpdate(mappedCollection);
writer.Complete();
}
////now that the data is in there, we need to setup some structure... probably a nicer way to do this but whatevs... its just for testing
//using (var writer = mappingGroup.CreateReadWriteUnitOfWork())
//{
// var homeSchema = writer.ReadWriteRepository.GetEntity<EntitySchema>(HiveId.ConvertIntToGuid(1045));
// var contentSchema = writer.ReadWriteRepository.GetEntity<EntitySchema>(HiveId.ConvertIntToGuid(1045));
// var faqContainerSchema = writer.ReadWriteRepository.GetEntity<EntitySchema>(HiveId.ConvertIntToGuid(1055));
// var faqCatSchema = writer.ReadWriteRepository.GetEntity<EntitySchema>(HiveId.ConvertIntToGuid(1056));
// var faqSchema = writer.ReadWriteRepository.GetEntity<EntitySchema>(HiveId.ConvertIntToGuid(1057));
//}
}
public static Revision<TypedEntity> CreateVersionedTypedEntity(EntitySchema schema, TypedAttribute[] attribs)
{
var entity = new Revision<TypedEntity>
{
Item = new TypedEntity
{
EntitySchema = schema
}
};
entity.Item.Attributes.Reset(attribs);
entity.MetaData = new RevisionData();
return entity;
}
public static TypedEntity CreateTypedEntity(EntitySchema schema, TypedAttribute[] attribs, bool assignId = false)
{
var entity = new TypedEntity
{
EntitySchema = schema
};
entity.Attributes.Reset(attribs);
if (assignId)
entity.Id = new HiveId(Guid.NewGuid());
return entity;
}
public void Update()
{
EntitySchema schema = new EntitySchema(EntityType, Category, SupportedEntities);
EntitySchema.AddSchema(schema);
foreach ( var item in Attributes )
{
schema.AddAttribute(item.Key, item.Value);
}
}
public static EntitySchema CreateEntitySchema(string alias, string name, bool assignId, params AttributeDefinition[] attributeDefinitions)
{
var def = new EntitySchema();
def.Setup(alias, name);
def.AttributeDefinitions.AddRange(attributeDefinitions);
if (assignId)
def.Id = new HiveId(Guid.NewGuid());
return def;
}
