コード例 #1
0
        /// <summary>
        /// Creates entity relation
        /// </summary>
        /// <param name="entity"></param>
        public bool Create(IStorageEntityRelation entityRelation)
        {
            if (entityRelation == null)
            {
                throw new ArgumentNullException("entityRelation");
            }

            var mongoEntityRelation = entityRelation as MongoEntityRelation;

            if (mongoEntityRelation == null)
            {
                throw new Exception("The specified entityRelation is not mongo storage object.");
            }

            MongoTransaction transaction = null;

            if (!MongoStaticContext.Context.TransactionInProgress)
            {
                transaction = MongoStaticContext.Context.CreateTransaction(true, new MongoTransactionOptions {
                    Isolation = MongoTransactionIsolation.ReadUncommitted
                });
            }

            lock (lockObject)
            {
                try
                {
                    cachedRelations = null;
                    var created    = MongoStaticContext.Context.EntityRelations.Create(mongoEntityRelation);
                    var relation   = Read(mongoEntityRelation.Name);
                    var recRepo    = new MongoRecordRepository();
                    var entityRepo = new MongoEntityRepository();

                    var originEntity = entityRepo.Read(relation.OriginEntityId);
                    var targetEntity = entityRepo.Read(relation.TargetEntityId);

                    recRepo.CreateRecordField(originEntity.Name, $"#{relation.Name}_targets", null);
                    recRepo.CreateRecordField(targetEntity.Name, $"#{relation.Name}_origins", null);

                    InvalidateRelationIndex(relation);

                    if (transaction != null)
                    {
                        transaction.Commit();
                    }

                    cachedRelations = null;
                    return(created);
                }
                catch
                {
                    if (transaction != null)
                    {
                        transaction.Rollback();
                    }

                    throw;
                }
            }
        }
コード例 #2
0
        /// <summary>
        /// Deletes entity relation
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool Delete(Guid id)
        {
            lock (lockObject)
            {
                MongoTransaction transaction = null;
                if (!MongoStaticContext.Context.TransactionInProgress)
                {
                    transaction = MongoStaticContext.Context.CreateTransaction();
                }

                try
                {
                    var relation = Read(id);

                    var recRepo      = new MongoRecordRepository();
                    var entityRepo   = new MongoEntityRepository();
                    var originEntity = entityRepo.Read(relation.OriginEntityId);
                    var targetEntity = entityRepo.Read(relation.TargetEntityId);

                    recRepo.RemoveRecordField(originEntity.Name, $"#{relation.Name}_targets");
                    recRepo.RemoveRecordField(targetEntity.Name, $"#{relation.Name}_origins");

                    InvalidateRelationIndex(relation, dropIndexes: true);

                    var result = MongoStaticContext.Context.EntityRelations.Delete(Query.EQ("_id", id));

                    if (transaction != null)
                    {
                        transaction.Commit();
                    }

                    cachedRelations = null;
                    return(result);
                }
                catch
                {
                    if (transaction != null)
                    {
                        transaction.Rollback();
                    }

                    throw;
                }
            }
        }
コード例 #3
0
        private void InvalidateRelationIndex(IStorageEntityRelation entityRelation, bool dropIndexes = false)
        {
            var entityRepository = new MongoEntityRepository();

            var originEntity = entityRepository.Read(entityRelation.OriginEntityId);
            var targetEntity = entityRepository.Read(entityRelation.TargetEntityId);

            if (originEntity == null || targetEntity == null)
            {
                return;
            }

            IStorageField originField = originEntity.Fields.SingleOrDefault(x => x.Id == entityRelation.OriginFieldId);
            IStorageField targetField = targetEntity.Fields.SingleOrDefault(x => x.Id == entityRelation.TargetFieldId);

            if (originField == null || targetField == null)
            {
                return;
            }

            if (entityRelation.RelationType != Api.Models.EntityRelationType.ManyToMany)
            {
                var originCollection = MongoStaticContext.Context.GetBsonCollection(MongoRecordRepository.RECORD_COLLECTION_PREFIX + originEntity.Name);
                if (originCollection == null)
                {
                    return;
                }

                if (originField.Name != "id")
                {
                    var originIndexes   = originCollection.GetIndexes();
                    var originIndexName = "relation_" + entityRelation.Name + "_" + originField.Name;
                    var originIndex     = originIndexes.SingleOrDefault(x => x.Name == originIndexName);
                    if (originIndex != null)
                    {
                        originCollection.DropIndexByName(originIndexName);
                    }

                    if (!dropIndexes)
                    {
                        IndexOptionsBuilder options = IndexOptions.SetUnique(false).SetDropDups(false).SetName(originIndexName).SetBackground(true);
                        originCollection.CreateIndex(new IndexKeysBuilder().Ascending(originField.Name), options);
                    }
                }

                var targetCollection = MongoStaticContext.Context.GetBsonCollection(MongoRecordRepository.RECORD_COLLECTION_PREFIX + targetEntity.Name);
                if (targetEntity == null)
                {
                    return;
                }

                if (targetField.Name != "id")
                {
                    var targetIndexes   = targetCollection.GetIndexes();
                    var targetIndexName = "relation_" + entityRelation.Name + "_" + targetField.Name;
                    var targetIndex     = targetIndexes.SingleOrDefault(x => x.Name == targetIndexName);
                    if (targetIndex != null)
                    {
                        targetCollection.DropIndexByName(targetIndexName);
                    }

                    if (!dropIndexes)
                    {
                        IndexOptionsBuilder options = IndexOptions.SetUnique(false).SetDropDups(false).SetName(targetIndexName).SetBackground(true);
                        targetCollection.CreateIndex(new IndexKeysBuilder().Ascending(targetField.Name), options);
                    }
                }
            }
            else
            {
                //at the moment many to many relation do not need any endexes

                /*
                 * var originCollection = MongoStaticContext.Context.GetBsonCollection(MongoRecordRepository.RECORD_COLLECTION_PREFIX + originEntity.Name);
                 * if (originCollection == null)
                 *      return;
                 *
                 * var originIndexes = originCollection.GetIndexes();
                 * var originIndexName = "relation_" + entityRelation.Name + "_targets";
                 * var originIndex = originIndexes.SingleOrDefault(x => x.Name == originIndexName);
                 * if (originIndex != null)
                 *      originCollection.DropIndexByName(originIndexName);
                 *
                 * if (!dropIndexes)
                 * {
                 *      var originFieldName = $"#" + entityRelation.Name + "_targets";
                 *      IndexOptionsBuilder options = IndexOptions.SetUnique(false).SetDropDups(false).SetName(originIndexName).SetBackground(true);
                 *      originCollection.CreateIndex(new IndexKeysBuilder().Ascending(originFieldName), options);
                 * }
                 *
                 * var targetCollection = MongoStaticContext.Context.GetBsonCollection(MongoRecordRepository.RECORD_COLLECTION_PREFIX + targetEntity.Name);
                 * if (targetEntity == null)
                 *      return;
                 *
                 * var targetIndexes = targetCollection.GetIndexes();
                 * var targetIndexName = "relation_" + entityRelation.Name + "_origins";
                 * var targetIndex = targetIndexes.SingleOrDefault(x => x.Name == targetIndexName);
                 * if (targetIndex != null)
                 *      targetCollection.DropIndexByName(targetIndexName);
                 *
                 * if (!dropIndexes)
                 * {
                 *      var targetFieldName = $"#" + entityRelation.Name + "_origins";
                 *      IndexOptionsBuilder options = IndexOptions.SetUnique(false).SetDropDups(false).SetName(targetIndexName).SetBackground(true);
                 *      targetCollection.CreateIndex(new IndexKeysBuilder().Ascending(targetFieldName), options);
                 * }
                 */
            }
        }
コード例 #4
0
        /// <summary>
        /// Deletes many to many relation record
        /// </summary>
        /// <param name="relationId"></param>
        /// <param name="originId"></param>
        /// <param name="targetId"></param>
        public void DeleteManyToManyRecord(Guid relationId, Guid originId, Guid targetId)
        {
            var entityRepository = new MongoEntityRepository();
            var relation         = Read(relationId);
            var originEntity     = entityRepository.Read(relation.OriginEntityId);
            var originField      = originEntity.Fields.Single(x => x.Id == relation.OriginFieldId);
            var targetEntity     = entityRepository.Read(relation.TargetEntityId);
            var targetField      = targetEntity.Fields.Single(x => x.Id == relation.TargetFieldId);

            var originColletion = MongoStaticContext.Context.GetBsonCollection("rec_" + originEntity.Name);
            var originFieldName = originField.Name;

            if (originFieldName == "id")
            {
                originFieldName = "_id";
            }
            var          originRecords      = originColletion.Find(Query.EQ(originFieldName, originId)).ToList();
            var          originRecordsCount = originRecords.Count();
            BsonDocument originRecord       = null;

            if (originRecordsCount == 0)
            {
                throw new StorageException("There are no record with specified origin id.");
            }
            else if (originRecordsCount > 1)
            {
                throw new StorageException("There are more than 1 record with same origin id.");
            }
            else
            {
                originRecord = originRecords[0];
                var         targetsElementName = $"#{ relation.Name}_targets";
                BsonElement bsonElement        = null;
                try { bsonElement = originRecord.GetElement(targetsElementName); } catch { }
                if (bsonElement != null)
                {
                    var targets = BsonTypeMapper.MapToDotNetValue(bsonElement.Value) as List <object>;
                    if (targets != null && targets.Contains(targetId))
                    {
                        targets.Remove(targetId);
                        if (targets.Count == 0)
                        {
                            targets = null;
                        }
                        originRecord[targetsElementName] = BsonTypeMapper.MapToBsonValue(targets);
                    }
                }
                else
                {
                    originRecord[targetsElementName] = BsonTypeMapper.MapToBsonValue(null);
                }
            }

            var targetColletion = MongoStaticContext.Context.GetBsonCollection("rec_" + targetEntity.Name);
            var targetFieldName = targetField.Name;

            if (targetFieldName == "id")
            {
                targetFieldName = "_id";
            }
            var          targetRecords      = targetColletion.Find(Query.EQ(targetFieldName, targetId)).ToList();
            var          targetRecordsCount = targetRecords.Count();
            BsonDocument targetRecord       = null;

            if (targetRecordsCount == 0)
            {
                throw new StorageException("There are no record with specified target id.");
            }
            else if (targetRecordsCount > 1)
            {
                throw new StorageException("There are more than 1 record with same target id.");
            }
            else
            {
                targetRecord = targetRecords[0];
                var         originsElementName = $"#{ relation.Name}_origins";
                BsonElement bsonElement        = null;
                try { bsonElement = targetRecord.GetElement(originsElementName); } catch { }
                if (bsonElement != null)
                {
                    var origins = BsonTypeMapper.MapToDotNetValue(bsonElement.Value) as List <object>;
                    if (origins != null && origins.Contains(originId))
                    {
                        origins.Remove(originId);
                        if (origins.Count == 0)
                        {
                            origins = null;
                        }
                        targetRecord[originsElementName] = BsonTypeMapper.MapToBsonValue(origins);
                    }
                }
                else
                {
                    targetRecord[originsElementName] = BsonTypeMapper.MapToBsonValue(null);
                }
            }

            MongoTransaction transaction = null;

            if (!MongoStaticContext.Context.TransactionInProgress)
            {
                transaction = MongoStaticContext.Context.CreateTransaction();
            }

            try
            {
                originColletion.Save(originRecord);
                targetColletion.Save(targetRecord);

                if (transaction != null)
                {
                    transaction.Commit();
                }
            }
            catch
            {
                if (transaction != null)
                {
                    transaction.Rollback();
                }

                throw;
            }
        }
コード例 #5
0
		/// <summary>
		/// Creates entity relation
		/// </summary>
		/// <param name="entity"></param>
		public bool Create(IStorageEntityRelation entityRelation)
		{
			if (entityRelation == null)
				throw new ArgumentNullException("entityRelation");

			var mongoEntityRelation = entityRelation as MongoEntityRelation;

			if (mongoEntityRelation == null)
				throw new Exception("The specified entityRelation is not mongo storage object.");

			MongoTransaction transaction = null;
			if (!MongoStaticContext.Context.TransactionInProgress)
				transaction = MongoStaticContext.Context.CreateTransaction( true, new MongoTransactionOptions { Isolation= MongoTransactionIsolation.ReadUncommitted});

			lock (lockObject)
			{
				try
				{
					cachedRelations = null;
					var created = MongoStaticContext.Context.EntityRelations.Create(mongoEntityRelation);
					var relation = Read(mongoEntityRelation.Name);
					var recRepo = new MongoRecordRepository();
					var entityRepo = new MongoEntityRepository();

					var originEntity = entityRepo.Read(relation.OriginEntityId);
					var targetEntity = entityRepo.Read(relation.TargetEntityId);

					recRepo.CreateRecordField(originEntity.Name, $"#{relation.Name}_targets", null);
					recRepo.CreateRecordField(targetEntity.Name, $"#{relation.Name}_origins", null);

					InvalidateRelationIndex(relation);

					if (transaction != null)
                    transaction.Commit();

					cachedRelations = null;
					return created;
				}
				catch
				{
					if (transaction != null)
					transaction.Rollback();

					throw;
				}
			}
		}
コード例 #6
0
		private void InvalidateRelationIndex(IStorageEntityRelation entityRelation, bool dropIndexes = false )
		{

			var entityRepository = new MongoEntityRepository();

			var originEntity = entityRepository.Read(entityRelation.OriginEntityId);
			var targetEntity = entityRepository.Read(entityRelation.TargetEntityId);

			if (originEntity == null || targetEntity == null)
				return;

			IStorageField originField = originEntity.Fields.SingleOrDefault(x => x.Id == entityRelation.OriginFieldId);
			IStorageField targetField = targetEntity.Fields.SingleOrDefault(x => x.Id == entityRelation.TargetFieldId);

			if (originField == null || targetField == null)
				return;

			if (entityRelation.RelationType != Api.Models.EntityRelationType.ManyToMany)
			{
				var originCollection = MongoStaticContext.Context.GetBsonCollection(MongoRecordRepository.RECORD_COLLECTION_PREFIX + originEntity.Name);
				if (originCollection == null)
					return;

				if (originField.Name != "id")
				{
					var originIndexes = originCollection.GetIndexes();
					var originIndexName = "relation_" + entityRelation.Name + "_" + originField.Name;
					var originIndex = originIndexes.SingleOrDefault(x => x.Name == originIndexName);
					if (originIndex != null)
						originCollection.DropIndexByName(originIndexName);

					if (!dropIndexes)
					{
						IndexOptionsBuilder options = IndexOptions.SetUnique(false).SetDropDups(false).SetName(originIndexName).SetBackground(true);
						originCollection.CreateIndex(new IndexKeysBuilder().Ascending(originField.Name), options);
					}
				}

				var targetCollection = MongoStaticContext.Context.GetBsonCollection(MongoRecordRepository.RECORD_COLLECTION_PREFIX + targetEntity.Name);
				if (targetEntity == null)
					return;

				if (targetField.Name != "id")
				{
					var targetIndexes = targetCollection.GetIndexes();
					var targetIndexName = "relation_" + entityRelation.Name + "_" + targetField.Name;
					var targetIndex = targetIndexes.SingleOrDefault(x => x.Name == targetIndexName);
					if (targetIndex != null)
						targetCollection.DropIndexByName(targetIndexName);

					if (!dropIndexes)
					{
						IndexOptionsBuilder options = IndexOptions.SetUnique(false).SetDropDups(false).SetName(targetIndexName).SetBackground(true);
						targetCollection.CreateIndex(new IndexKeysBuilder().Ascending(targetField.Name), options);
					}
				}
			}
			else
			{
				//at the moment many to many relation do not need any endexes
				/*
				var originCollection = MongoStaticContext.Context.GetBsonCollection(MongoRecordRepository.RECORD_COLLECTION_PREFIX + originEntity.Name);
				if (originCollection == null)
					return;

				var originIndexes = originCollection.GetIndexes();
				var originIndexName = "relation_" + entityRelation.Name + "_targets";
				var originIndex = originIndexes.SingleOrDefault(x => x.Name == originIndexName);
				if (originIndex != null)
					originCollection.DropIndexByName(originIndexName);

				if (!dropIndexes)
				{
					var originFieldName = $"#" + entityRelation.Name + "_targets";
					IndexOptionsBuilder options = IndexOptions.SetUnique(false).SetDropDups(false).SetName(originIndexName).SetBackground(true);
					originCollection.CreateIndex(new IndexKeysBuilder().Ascending(originFieldName), options);
				}

				var targetCollection = MongoStaticContext.Context.GetBsonCollection(MongoRecordRepository.RECORD_COLLECTION_PREFIX + targetEntity.Name);
				if (targetEntity == null)
					return;

				var targetIndexes = targetCollection.GetIndexes();
				var targetIndexName = "relation_" + entityRelation.Name + "_origins";
				var targetIndex = targetIndexes.SingleOrDefault(x => x.Name == targetIndexName);
				if (targetIndex != null)
					targetCollection.DropIndexByName(targetIndexName);

				if (!dropIndexes)
				{
					var targetFieldName = $"#" + entityRelation.Name + "_origins";
					IndexOptionsBuilder options = IndexOptions.SetUnique(false).SetDropDups(false).SetName(targetIndexName).SetBackground(true);
					targetCollection.CreateIndex(new IndexKeysBuilder().Ascending(targetFieldName), options);
				}
				*/
			}

		}
コード例 #7
0
		/// <summary>
		/// Deletes many to many relation record
		/// </summary>
		/// <param name="relationId"></param>
		/// <param name="originId"></param>
		/// <param name="targetId"></param>
		public void DeleteManyToManyRecord(Guid relationId, Guid originId, Guid targetId)
		{
			var entityRepository = new MongoEntityRepository();
			var relation = Read(relationId);
			var originEntity = entityRepository.Read(relation.OriginEntityId);
			var originField = originEntity.Fields.Single(x => x.Id == relation.OriginFieldId);
			var targetEntity = entityRepository.Read(relation.TargetEntityId);
			var targetField = targetEntity.Fields.Single(x => x.Id == relation.TargetFieldId);

			var originColletion = MongoStaticContext.Context.GetBsonCollection("rec_" + originEntity.Name);
			var originFieldName = originField.Name;
			if (originFieldName == "id")
				originFieldName = "_id";
			var originRecords = originColletion.Find(Query.EQ(originFieldName, originId)).ToList();
			var originRecordsCount = originRecords.Count();
			BsonDocument originRecord = null;
			if (originRecordsCount == 0)
				throw new StorageException("There are no record with specified origin id.");
			else if (originRecordsCount > 1)
				throw new StorageException("There are more than 1 record with same origin id.");
			else
			{
				originRecord = originRecords[0];
				var targetsElementName = $"#{ relation.Name}_targets";
				BsonElement bsonElement = null;
				if (originRecord.Elements.Any(x => x.Name == targetsElementName))
					bsonElement = originRecord.GetElement(targetsElementName);
				//try { bsonElement = originRecord.GetElement(targetsElementName); } catch { }
				if (bsonElement != null)
				{
					var targets = BsonTypeMapper.MapToDotNetValue(bsonElement.Value) as List<object>;
					if (targets != null && targets.Contains(targetId))
					{
						targets.Remove(targetId);
						if (targets.Count == 0)
							targets = null;
						originRecord[targetsElementName] = BsonTypeMapper.MapToBsonValue(targets);
					}
				}
				else
					originRecord[targetsElementName] = BsonTypeMapper.MapToBsonValue(null);
			}

			var targetColletion = MongoStaticContext.Context.GetBsonCollection("rec_" + targetEntity.Name);
			var targetFieldName = targetField.Name;
			if (targetFieldName == "id")
				targetFieldName = "_id";
			var targetRecords = targetColletion.Find(Query.EQ(targetFieldName, targetId)).ToList();
			var targetRecordsCount = targetRecords.Count();
			BsonDocument targetRecord = null;
			if (targetRecordsCount == 0)
				throw new StorageException("There are no record with specified target id.");
			else if (targetRecordsCount > 1)
				throw new StorageException("There are more than 1 record with same target id.");
			else
			{
				targetRecord = targetRecords[0];
				var originsElementName = $"#{ relation.Name}_origins";
				BsonElement bsonElement = null;
				if (targetRecord.Elements.Any(x => x.Name == originsElementName))
					bsonElement = targetRecord.GetElement(originsElementName);
				//try { bsonElement = targetRecord.GetElement(originsElementName); } catch { }
				if (bsonElement != null)
				{
					var origins = BsonTypeMapper.MapToDotNetValue(bsonElement.Value) as List<object>;
					if (origins != null && origins.Contains(originId))
					{
						origins.Remove(originId);
						if (origins.Count == 0)
							origins = null;
						targetRecord[originsElementName] = BsonTypeMapper.MapToBsonValue(origins);
					}
				}
				else
					targetRecord[originsElementName] = BsonTypeMapper.MapToBsonValue(null);
			}

			MongoTransaction transaction = null;
			if (!MongoStaticContext.Context.TransactionInProgress)
				transaction = MongoStaticContext.Context.CreateTransaction();

			try
			{
				originColletion.Save(originRecord);
				targetColletion.Save(targetRecord);

				if (transaction != null)
					transaction.Commit();
			}
			catch
			{
				if (transaction != null)
					transaction.Rollback();

				throw;
			}
		}
コード例 #8
0
		/// <summary>
		/// Deletes entity relation 
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		public bool Delete(Guid id)
		{
			lock (lockObject)
			{
				MongoTransaction transaction = null;
				if(!MongoStaticContext.Context.TransactionInProgress)
					transaction = MongoStaticContext.Context.CreateTransaction();

				try
				{
					var relation = Read(id);

					var recRepo = new MongoRecordRepository();
					var entityRepo = new MongoEntityRepository();
					var originEntity = entityRepo.Read(relation.OriginEntityId);
					var targetEntity = entityRepo.Read(relation.TargetEntityId);

					recRepo.RemoveRecordField(originEntity.Name, $"#{relation.Name}_targets");
					recRepo.RemoveRecordField(targetEntity.Name, $"#{relation.Name}_origins");

					InvalidateRelationIndex(relation, dropIndexes: true);

					var result = MongoStaticContext.Context.EntityRelations.Delete(Query.EQ("_id", id));

					if (transaction != null)
					transaction.Commit();

					cachedRelations = null;
					return result;
				}
				catch
				{
					if (transaction != null)
					transaction.Rollback();

					throw;
				}
			}
		}