Exemplo n.º 1
0
        public override IQueryOver <CertificateQuality, CertificateQuality> Filtering(
            IQueryOver <CertificateQuality, CertificateQuality> query, CertificateQualityFilter filter)
        {
            query.FindByRn(filter.Rn);

            query.IsBetween(x => x.CreationDate, filter.CreationDate);
            query.IsBetween(x => x.StorageDate, filter.StorageDate);
            query.IsBetween(x => x.MakingDate, filter.MakingDate);

            query.IsLike(x => x.StandardSize, filter.StandardSize.ReplaceStar());
            query.IsLike(x => x.NomerCertificata, filter.NomerCertificata.ReplaceStar());
            query.IsLike(x => x.ModeThermoTreatment, filter.ModeThermoTreatment.ReplaceStar());
            query.IsLike(x => x.Mix, filter.Mix.ReplaceStar());
            query.IsLike(x => x.Marka, filter.Marka.ReplaceStar());
            query.IsLike(x => x.GostMix, filter.GostMix.ReplaceStar());
            query.IsLike(x => x.GostMarka, filter.GostMarka.ReplaceStar());
            query.IsLike(x => x.FullRepresentation, filter.FullRepresentation.ReplaceStar());
            query.IsLike(x => x.DeliveryCondition, filter.DeliveryCondition.ReplaceStar());
            query.IsLike(x => x.Cast, filter.Cast.ReplaceStar());

            query.IsIn(x => x.State, filter.State);
            if (filter.UserCreator != null)
            {
                query.Where(x => x.UserCreator.Rn == filter.UserCreator.Rn);
            }

            if (!string.IsNullOrWhiteSpace(filter.Pref))
            {
                query.Where(x => x.Pref == filter.Pref);
            }

            if (filter.Numb != null)
            {
                query.Where(x => x.Numb == filter.Numb);
            }

            if (filter.CreatorFactory != null)
            {
                query.Where(x => x.CreatorFactory.Rn == filter.CreatorFactory.Rn);
            }

            if (filter.NomenclatureNumber != null)
            {
                query.JoinQueryOver(x => x.PlanCertificate, JoinType.LeftOuterJoin);
                NomenclatureNumberModification nommodifAlias = null;
                query.JoinAlias(x => x.PlanCertificate.ModificationNomenclature, () => nommodifAlias, JoinType.LeftOuterJoin);

                query.Where(x => nommodifAlias.Code == filter.NomenclatureNumber.Code);
            }

            return(query);
        }
        /// <summary>
        /// The filtering.
        /// </summary>
        /// <param name="query">
        /// The query.
        /// </param>
        /// <param name="filter">
        /// The filter.
        /// </param>
        /// <returns>
        /// The <see cref="IQueryOver"/>.
        /// </returns>
        public override IQueryOver <PlanReceiptOrder, PlanReceiptOrder> Filtering(
            IQueryOver <PlanReceiptOrder, PlanReceiptOrder> query, PlanReceiptOrderFilter filter)
        {
            query.FindByRn(filter.Rn);

            query.IsBetween(x => x.CreationDate, filter.CreationDate);
            query.IsBetween(x => x.GroundDocumentDate, filter.GroundDocumentDate);

            query.IsLike(x => x.GroundDocumentNumb, filter.GroundDocumentNumb, MatchMode.Start);
            query.IsLike(x => x.Note, filter.Note, MatchMode.Start);
            query.IsLike(x => x.Pref, filter.Pref, MatchMode.Start);
            query.IsBetween(x => x.StateDate, filter.StateDate);

            if (filter.Numb != null)
            {
                query.Where(x => x.Numb == filter.Numb);
            }

            if (filter.States.Any())
            {
                query.WhereRestrictionOn(x => x.State)
                .IsIn(filter.States.ToArray());
            }

            if (filter.PlanCertificate != null)
            {
                if (filter.PlanCertificate.ModificationNomenclature != null)
                {
                    if (filter.PlanCertificate.ModificationNomenclature.NomenclatureNumber != null)
                    {
                        if (!string.IsNullOrWhiteSpace(filter.PlanCertificate.ModificationNomenclature.NomenclatureNumber.Code))
                        {
                            query.JoinQueryOver(x => x.PlanCertificates, JoinType.LeftOuterJoin);
                            NomenclatureNumberModification nommodifAlias = null;
                            query.JoinAlias((x) => filter.PlanCertificate.ModificationNomenclature, () => nommodifAlias, JoinType.LeftOuterJoin);

                            NomenclatureNumber nomenclatureNumberAlias = null;
                            query.JoinQueryOver(() => nommodifAlias.NomenclatureNumber, () => nomenclatureNumberAlias, JoinType.LeftOuterJoin);

                            query.WhereRestrictionOn(() => nomenclatureNumberAlias.NomenCode)
                            .IsLike(
                                filter.PlanCertificate.ModificationNomenclature.NomenclatureNumber.Code
                                .ReplaceStar());
                        }
                    }
                }
            }

            if (filter.StaffingDivision != null)
            {
                if (filter.StaffingDivision.Code != null && filter.StaffingDivision.Code.Any())
                {
                    query.JoinQueryOver(x => x.StaffingDivision, JoinType.LeftOuterJoin)
                    .WhereRestrictionOn(x => x.Code)
                    .IsIn(filter.StaffingDivision.Code.ToArray());
                }
            }

            if (filter.StoreGasStationOilDepot != null)
            {
                if (!string.IsNullOrWhiteSpace(filter.StoreGasStationOilDepot.AzsNumber))
                {
                    query.JoinQueryOver(x => x.StoreGasStationOilDepot, JoinType.LeftOuterJoin)
                    .Where(x => x.Number == filter.StoreGasStationOilDepot.AzsNumber);
                }
            }

            if (!string.IsNullOrWhiteSpace(filter.GroundTypeOfDocument.DocCode))
            {
                query.JoinQueryOver(x => x.GroundTypeOfDocument, JoinType.LeftOuterJoin)
                .Where(x => x.DocumentCode == filter.GroundTypeOfDocument.DocCode);
            }

            return(query);
        }