public EntityRelationResponse Create(EntityRelation relation)
        {
            EntityRelationResponse response = new EntityRelationResponse();
            response.Timestamp = DateTime.UtcNow;
            response.Object = relation;
            response.Errors = ValidateRelation(relation, ValidationType.Create);
            if (response.Errors.Count > 0)
            {
                response.Success = false;
                response.Message = "The entity relation was not created. Validation error occurred!";
                return response;
            }

            try
            {
                var storageRelation = relation.MapTo<IStorageEntityRelation>();

                if (storageRelation.Id == Guid.Empty)
                    storageRelation.Id = Guid.NewGuid();

                var success = relationRepository.Create(storageRelation);

                if (success)
                {
                    response.Success = true;
                    response.Message = "The entity relation was successfully created!";
                    return response;
                }
                else
                {

                    response.Success = false;
                    response.Message = "The entity relation was not created! An internal error occurred!";
                    return response;
                }
            }
            catch (Exception e)
            {
                response.Success = false;
                response.Object = relation;
                response.Timestamp = DateTime.UtcNow;
            #if DEBUG
                response.Message = e.Message + e.StackTrace;
            #else
                response.Message = "The entity relation was not created. An internal error occurred!";
            #endif
                return response;
            }
        }
        public EntityRelationResponse Delete(Guid relationId)
        {
            EntityRelationResponse response = new EntityRelationResponse();
            response.Timestamp = DateTime.UtcNow;
            response.Success = false;
            response.Object = null;

            try
            {

                var storageRelation = relationRepository.Read(relationId);
                if (storageRelation != null)
                {
                    relationRepository.Delete(relationId);
                    response.Object = storageRelation.MapTo<EntityRelation>();
                    response.Success = true;
                    response.Message = "The entity relation was deleted!";
                    return response;
                }
                else
                {
                    response.Message = string.Format("The entity relation was not deleted! No instance with specified id ({0}) was found!", relationId);
                    return response;
                }
            }
            catch (Exception e)
            {
            #if DEBUG
                response.Message = string.Format("Relation ID: {0}, /r/nMessage:{1}/r/nStackTrace:{2}", relationId, e.Message, e.StackTrace);
            #else
                response.Message = "The entity relation was not delete. An internal error occurred!";
            #endif
                return response;
            }
        }
        public EntityRelationResponse Read(Guid relationId)
        {
            EntityRelationResponse response = new EntityRelationResponse();
            response.Timestamp = DateTime.UtcNow;
            response.Object = null;
            response.Success = true;
            try
            {
                var storageRelation = relationRepository.Read(relationId);
                if (storageRelation != null)
                {
                    response.Object = storageRelation.MapTo<EntityRelation>();
                    response.Message = "The entity relation was successfully returned!";
                }
                else
                    response.Message = string.Format("The entity relation '{0}' does not exist!", relationId);

                return response;
            }
            catch (Exception e)
            {
                response.Success = false;
            #if DEBUG
                response.Message = e.Message + e.StackTrace;
            #endif
                return response;
            }
        }
        public EntityRelationResponse Read(string name)
        {
            EntityRelationResponse response = new EntityRelationResponse();
            response.Timestamp = DateTime.UtcNow;
            response.Object = null;

            if (string.IsNullOrWhiteSpace(name))
            {
                response.Success = false;
                response.Errors.Add(new ErrorModel("name", null, "The name argument is NULL."));
                return response;
            }

            try
            {
                IStorageEntityRelation storageRelation = relationRepository.Read(name);
                response.Success = false;

                if (storageRelation != null)
                {
                    response.Object = storageRelation.MapTo<EntityRelation>();
                    response.Success = true;
                    response.Message = "The entity relation was successfully returned!";
                }
                else
                {
                    response.Success = true;
                    response.Message = string.Format("The entity relation '{0}' does not exist!", name);
                }
                return response;
            }
            catch (Exception e)
            {
                response.Success = false;
            #if DEBUG
                response.Message = e.Message + e.StackTrace;
            #endif
                return response;
            }
        }
        public EntityRelationResponse Read(Guid relationId)
        {
            EntityRelationResponse response = new EntityRelationResponse();
            response.Timestamp = DateTime.UtcNow;
            response.Object = null;
            response.Success = true;
            try
            {
                var relations = Cache.GetRelations();
                if (relations != null)
                {
                    response.Object = relations.SingleOrDefault(x => x.Id == relationId);
                    response.Success = true;
                    if (response.Object != null)
                        response.Message = "The entity relation was successfully returned!";
                    else
                        response.Message = string.Format("The entity relation with id '{0}' does not exist!", relationId);
                    return response;
                }

                relations = Read().Object;
                response.Object = relations.SingleOrDefault( x=>x.Id == relationId);
                if (response.Object != null)
                {
                    response.Message = "The entity relation was successfully returned!";
                }
                else
                    response.Message = string.Format("The entity relation '{0}' does not exist!", relationId);

                return response;
            }
            catch (Exception e)
            {
                response.Success = false;
            #if DEBUG
                response.Message = e.Message + e.StackTrace;
            #endif
                return response;
            }
        }
        public EntityRelationResponse Read(string name)
        {
            EntityRelationResponse response = new EntityRelationResponse();
            response.Timestamp = DateTime.UtcNow;
            response.Object = null;

            if (string.IsNullOrWhiteSpace(name))
            {
                response.Success = false;
                response.Errors.Add(new ErrorModel("name", null, "The name argument is NULL."));
                return response;
            }

            var relations = Cache.GetRelations();
            if( relations != null )
            {
                response.Object = relations.SingleOrDefault(x => x.Name == name);
                response.Success = true;
                if(response.Object!=null)
                    response.Message = "The entity relation was successfully returned!";
                else
                    response.Message = string.Format("The entity relation '{0}' does not exist!", name);
                return response;
            }

            try
            {
                relations = Read().Object;
                response.Object = relations.SingleOrDefault(x => x.Name == name);
                response.Success = false;

                if (response.Object != null)
                {
                    response.Success = true;
                    response.Message = "The entity relation was successfully returned!";
                }
                else
                {
                    response.Success = true;
                    response.Message = string.Format("The entity relation '{0}' does not exist!", name);
                }
                return response;
            }
            catch (Exception e)
            {
                response.Success = false;
            #if DEBUG
                response.Message = e.Message + e.StackTrace;
            #endif
                return response;
            }
        }