Ejemplo n.º 1
0
        /// <summary>
        /// Examine criteria match on the provided entity.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <returns></returns>
        public override bool ResultForEntity(EntityBaseWithoutId entity)
        {
            if (entity == null)
            {
                ThrowHelper.ThrowArgumentNullException("entity");
            }

            ExtractObjectData of = ExtractObjectData.Create(FieldName);

            return(Negation ? of.GetValue(entity) != null : of.GetValue(entity) == null);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Examine criteria match on the provided entity.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <returns></returns>
        public override bool ResultForEntity(EntityBaseWithoutId entity)
        {
            if (entity == null)
            {
                ThrowHelper.ThrowArgumentNullException("entity");
            }

            bool result                  = false;
            ExtractObjectData ef         = ExtractObjectData.Create(FieldName);
            Object            fieldValue = ef.GetValue(entity);

            switch (Operand)
            {
            case ArithmeticOperandEnum.Equal:
                result = Value.CompareTo(fieldValue) == 0;
                break;

            case ArithmeticOperandEnum.NotEqual:
                result = Value.CompareTo(fieldValue) != 0;
                break;

            case ArithmeticOperandEnum.Greater:
                result = Value.CompareTo(fieldValue) < 0;
                break;

            case ArithmeticOperandEnum.Lower:
                result = Value.CompareTo(fieldValue) > 0;
                break;

            case ArithmeticOperandEnum.GreaterOrEqual:
                result = Value.CompareTo(fieldValue) <= 0;
                break;

            case ArithmeticOperandEnum.LowerOrEqual:
                result = Value.CompareTo(fieldValue) >= 0;
                break;

            default:
                throw new NotImplementedException();
            }

            if (Negation)
            {
                result = !result;
            }

            return(result);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Examine criteria match on the provided entity.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <returns></returns>
        public override bool ResultForEntity(EntityBaseWithoutId entity)
        {
            if (entity == null)
            {
                ThrowHelper.ThrowArgumentNullException("entity");
            }

            ExtractObjectData ef         = ExtractObjectData.Create(FieldName);
            object            fieldValue = ef.GetValue(entity);
            bool result = HiValue.CompareTo(fieldValue) >= 0 && LoValue.CompareTo(fieldValue) <= 0; // az értéknek a két érték közé kell esnie

            if (Negation)
            {
                // az értéknek nem szabad a két érték közé kell esnie
                result = !result;
            }
            return(result);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Examine criteria match on the provided entity.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <returns></returns>
        public override bool ResultForEntity(EntityBaseWithoutId entity)
        {
            if (entity == null)
            {
                ThrowHelper.ThrowArgumentNullException("entity");
            }

            bool result = false;

            ExtractObjectData ef          = ExtractObjectData.Create(FieldName);
            String            entityValue = ef.GetValue(entity).ToString();

            if (entityValue != null)
            {
                switch (MatchMode)
                {
                case LikeMatchModeEnum.Exact:
                    result = entityValue.ToLower().Equals(Value.ToLower());
                    break;

                case LikeMatchModeEnum.Start:
                    result = entityValue.ToLower().StartsWith(Value.ToLower());
                    break;

                case LikeMatchModeEnum.End:
                    result = entityValue.ToLower().EndsWith(Value.ToLower());
                    break;

                case LikeMatchModeEnum.Anywhere:
                    result = entityValue.ToLower().Contains(Value.ToLower());
                    break;

                default:
                    throw new NotImplementedException();
                }
            }

            if (Negation)
            {
                result = !result;
            }

            return(result);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Compares the specified left entity.
        /// </summary>
        /// <param name="leftEntity">The left entity.</param>
        /// <param name="rightEntity">The right entity.</param>
        /// <returns></returns>
        public int Compare(EntityBaseWithoutId leftEntity, EntityBaseWithoutId rightEntity)
        {
            if (leftEntity == null)
            {
                ThrowHelper.ThrowArgumentNullException("leftEntity");
            }
            if (rightEntity == null)
            {
                ThrowHelper.ThrowArgumentNullException("rightEntity");
            }

            int result = 0;

            ExtractObjectData of = ExtractObjectData.Create(FieldName);

            object entityValueLeft  = of.GetValue(leftEntity);
            object entityValueRight = of.GetValue(rightEntity);

            if (entityValueLeft == null && entityValueRight == null)
            {
                // egyenlőek
            }
            else if (entityValueLeft == null)
            {
                result = -1;
            }
            else if (entityValueRight == null)
            {
                result = 1;
            }
            else
            {
                result = ((IComparable)entityValueLeft).CompareTo(entityValueRight);
            }

            if (OrderMode.Equals(OrderModeEnum.Desc))
            {
                // revert order
                result = result * -1;
            }

            return(result);
        }
Ejemplo n.º 6
0
 private static void LogAssemblyNewProperties(Assembly a)
 {
     // Log assembly properties which are available in newer version of Framework.NET
     if (mIsDynamicAvailable)
     {
         try
         {
             ExtractObjectData e = ExtractObjectData.Create("IsDynamic");
             LOGGER.Info(string.Format("LOGUTILS, Assembly, IsDynamic: {0}", e.GetValue(a).ToString()));
         }
         catch (MissingFieldException)
         {
             mIsDynamicAvailable = false;
         }
         catch (MissingMemberException)
         {
             mIsDynamicAvailable = false;
         }
         catch (Exception) { }
     }
     if (mIsFullyTrustedAvailable)
     {
         try
         {
             ExtractObjectData e = ExtractObjectData.Create("IsFullyTrusted");
             LOGGER.Info(string.Format("LOGUTILS, Assembly, IsFullyTrusted: {0}", e.GetValue(a).ToString()));
         }
         catch (MissingFieldException)
         {
             mIsFullyTrustedAvailable = false;
         }
         catch (MissingMemberException)
         {
             mIsFullyTrustedAvailable = false;
         }
         catch (Exception) { }
     }
 }
Ejemplo n.º 7
0
        /// <summary>
        /// Filters the specified package.
        /// </summary>
        /// <param name="package">The package.</param>
        /// <returns>
        /// True, if the filter criterias matches, otherwise False.
        /// </returns>
        public override bool Filter(ReportPackage package)
        {
            DoInitializationCheck();

            bool result = false;

            string value = ExtractObjectData.Create(this.MemberName).GetValue(package).ToString();

            if (value != null)
            {
                switch (MatchMode)
                {
                case LikeMatchModeFilterEnum.Exact:
                    result = value.ToLower().Equals(Value.ToLower());
                    break;

                case LikeMatchModeFilterEnum.Start:
                    result = value.ToLower().StartsWith(Value.ToLower());
                    break;

                case LikeMatchModeFilterEnum.End:
                    result = value.ToLower().EndsWith(Value.ToLower());
                    break;

                case LikeMatchModeFilterEnum.Anywhere:
                    result = value.ToLower().Contains(Value.ToLower());
                    break;
                }
            }

            if (Negation)
            {
                result = !result;
            }

            return(result);
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Examine criteria match on the provided entity.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <returns></returns>
        public override bool ResultForEntity(EntityBaseWithoutId entity)
        {
            if (entity == null)
            {
                ThrowHelper.ThrowArgumentNullException("entity");
            }

            bool result = false;

            ExtractObjectData of          = ExtractObjectData.Create(FieldName);
            object            entityValue = of.GetValue(entity);

            foreach (object o in this.Values)
            {
                if (o == null && entityValue == null)
                {
                    result = true;
                    break;
                }
                else if (entityValue != null)
                {
                    if (entityValue.Equals(o))
                    {
                        result = true;
                        break;
                    }
                }
            }

            if (Negation)
            {
                result = !result;
            }

            return(result);
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Filters the specified package.
        /// </summary>
        /// <param name="package">The package.</param>
        /// <returns>
        /// True, if the filter criterias matches, otherwise False.
        /// </returns>
        public override bool Filter(ReportPackage package)
        {
            DoInitializationCheck();

            bool result = false;

            IComparable value = (IComparable)ExtractObjectData.Create(this.MemberName).GetValue(package);

            switch (this.Operand)
            {
            case ArithmeticFilterOperandEnum.Equal:
            {
                if (value == null && this.Value == null)
                {
                    result = true;
                }
                else if (value == null || this.Value == null)
                {
                }
                else
                {
                    result = value.Equals((IComparable)Convert.ChangeType(this.Value, value.GetType()));
                }
            }
            break;

            case ArithmeticFilterOperandEnum.NotEqual:
            {
                if (value == null && this.Value == null)
                {
                }
                else if (value == null || this.Value == null)
                {
                    result = true;
                }
                else
                {
                    result = !value.Equals((IComparable)Convert.ChangeType(this.Value, value.GetType()));
                }
            }
            break;

            case ArithmeticFilterOperandEnum.Greater:
            {
                if (this.Value == null)
                {
                    throw new NullReferenceException("Filter value is null");
                }
                if (value == null)
                {
                    throw new NullReferenceException(string.Format("Field or property value is null '{0}'", this.MemberName));
                }
                result = value.CompareTo((IComparable)Convert.ChangeType(this.Value, value.GetType())) < 0;
            }
            break;

            case ArithmeticFilterOperandEnum.Lower:
            {
                if (this.Value == null)
                {
                    throw new NullReferenceException("Filter value is null");
                }
                if (value == null)
                {
                    throw new NullReferenceException(string.Format("Field or property value is null '{0}'", this.MemberName));
                }
                result = value.CompareTo((IComparable)Convert.ChangeType(this.Value, value.GetType())) > 0;
            }
            break;

            case ArithmeticFilterOperandEnum.GreaterOrEqual:
            {
                if (this.Value == null)
                {
                    throw new NullReferenceException("Filter value is null");
                }
                if (value == null)
                {
                    throw new NullReferenceException(string.Format("Field or property value is null '{0}'", this.MemberName));
                }
                result = value.CompareTo((IComparable)Convert.ChangeType(this.Value, value.GetType())) <= 0;
            }
            break;

            case ArithmeticFilterOperandEnum.LowerOrEqual:
            {
                if (this.Value == null)
                {
                    throw new NullReferenceException("Filter value is null");
                }
                if (value == null)
                {
                    throw new NullReferenceException(string.Format("Field or property value is null '{0}'", this.MemberName));
                }
                result = value.CompareTo((IComparable)Convert.ChangeType(this.Value, value.GetType())) >= 0;
            }
            break;
            }

            return(result);
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Logs the loaded assemblies.
        /// </summary>
        public static void LogDomainInfo()
        {
            if (LOGGER.IsInfoEnabled)
            {
                AppDomain domain = AppDomain.CurrentDomain;

                LOGGER.Info(string.Format("LOGUTILS, Domain, Id: {0}", domain.Id.ToString()));
                LOGGER.Info(string.Format("LOGUTILS, Domain, base directory: {0}", domain.BaseDirectory));
                LOGGER.Info(string.Format("LOGUTILS, Domain, dynamic directory: {0}", domain.DynamicDirectory));
                LOGGER.Info(string.Format("LOGUTILS, Domain, friendly name: {0}", domain.FriendlyName));

                try
                {
                    ExtractObjectData e = ExtractObjectData.Create("IsFullyTrusted");
                    LOGGER.Info(string.Format("LOGUTILS, Domain, is fully trusted: {0}", e.GetValue(domain).ToString()));
                }
                catch (Exception) { }

                try
                {
                    ExtractObjectData e = ExtractObjectData.Create("IsHomogenous");
                    LOGGER.Info(string.Format("LOGUTILS, Domain, is homogenous: {0}", e.GetValue(domain).ToString()));
                }
                catch (Exception) { }

                LOGGER.Info(string.Format("LOGUTILS, Domain, relative search path: {0}", domain.RelativeSearchPath));
                LOGGER.Info(string.Format("LOGUTILS, Domain, shadow copy files: {0}", domain.ShadowCopyFiles));

                if (domain.SetupInformation != null)
                {
                    try
                    {
                        ExtractObjectData e = ExtractObjectData.Create("SetupInformation.AppDomainManagerAssembly");
                        LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, AppDomainManagerAssembly: {0}", e.GetValue(domain).ToString()));
                    }
                    catch (Exception) { }
                    try
                    {
                        ExtractObjectData e = ExtractObjectData.Create("SetupInformation.AppDomainManagerType");
                        LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, AppDomainManagerType: {0}", e.GetValue(domain).ToString()));
                    }
                    catch (Exception) { }

                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, ApplicationBase: {0}", domain.SetupInformation.ApplicationBase));
#if NETCOREAPP3_1
#else
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, ApplicationName: {0}", domain.SetupInformation.ApplicationName));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, CachePath: {0}", domain.SetupInformation.CachePath));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, ConfigurationFile: {0}", domain.SetupInformation.ConfigurationFile));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, DisallowApplicationBaseProbing: {0}", domain.SetupInformation.DisallowApplicationBaseProbing.ToString()));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, DisallowBindingRedirects: {0}", domain.SetupInformation.DisallowBindingRedirects.ToString()));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, DisallowCodeDownload: {0}", domain.SetupInformation.DisallowCodeDownload.ToString()));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, DisallowPublisherPolicy: {0}", domain.SetupInformation.DisallowPublisherPolicy.ToString()));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, DynamicBase: {0}", domain.SetupInformation.DynamicBase));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, LicenseFile: {0}", domain.SetupInformation.LicenseFile));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, LoaderOptimization: {0}", domain.SetupInformation.LoaderOptimization.ToString()));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, PrivateBinPath: {0}", domain.SetupInformation.PrivateBinPath));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, PrivateBinPathProbe: {0}", domain.SetupInformation.PrivateBinPathProbe));
                    //LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, SandboxInterop: {0}", domain.SetupInformation.SandboxInterop.ToString()));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, ShadowCopyDirectories: {0}", domain.SetupInformation.ShadowCopyDirectories));
                    LOGGER.Info(string.Format("LOGUTILS, Domain, Setup Information, ShadowCopyFiles: {0}", domain.SetupInformation.ShadowCopyFiles));
#endif
                }

                LOGGER.Info("--------------------------------------------------------");
            }
        }