Skocz do zawartości

Lista towarów do spakowania

Polecane posty

1 minutę temu, Radek A napisał:

Jeśli można hurtowo poprawić już przydzielone do tysięcy produktów to OK, ale nie widzę takiej opcji

A w jakim polu masz wpisany nr półki? i czy w Sello czy w Subiekcie?

 

 

1 minutę temu, Marek Axel napisał:

Możesz napisać dokładnie, w którym miejscu ustawia się sortowanie według magazynu?

Nie korzystam z funkcjonalności sortowania wg magazynu, opieram się na opisie autora:

obraz.png.f1df2c5adf1a357e7a945605f4089c5b.png

Możesz też popatrzeć w projektancie raportów w Sello, który parametr odpowiada za sortowanie i - może i metodą prób i błędów - ustawić go sobie wg potrzeb.

Link to postu
3 minuty temu, Radek A napisał:

W subiekcie, pola własne

Ja korzystam z dodatku, który z pomocą excela może wyeksportować i zaimportować dane. Więc zmiany to kilka minut...

Co do samego Subiekta to pewnie nie ma - tak jak piszesz. Ale może są spece, który wiedzą jak to zmienić w bazie danych...

Link to postu

Problem z sortowaniem 1,11,2 wynika stąd, że pola własne są traktowane jako tekst i tak też są sortowane.

Rozwiązań na to jest kilka. Można sprawić aby serwer SQL potraktował te dane jako liczby i wtedy posortuje je prawidłowo (ale nastąpi błąd gdy omyłkowo ktoś wstawi jakiś znak niebędący cyfrą w polu własnym) albo też dodać wiodące zera do wartości z tej kolumny - wtedy sortowanie alfabetyczne zadziała jak sortowanie po liczbach.

 

Nie zaglądałem do tego wydruku, ale zapewne gdzieś tam jest sortowanie dodane i można spróbować zmodyfikować je wg informacji z tej strony np. https://stackoverflow.com/questions/16519648/sql-for-ordering-by-number-1-2-3-4-etc-instead-of-1-10-11-12/16520873

 

Link to postu
W dniu 7.12.2020 o 16:55, MARCIN e-kupowanie.pl napisał:

Ja korzystam z dodatku, który z pomocą excela może wyeksportować i zaimportować dane. Więc zmiany to kilka minut...

Co do samego Subiekta to pewnie nie ma - tak jak piszesz. Ale może są spece, który wiedzą jak to zmienić w bazie danych...

Niestety jest to płatne rozwiązanie....

Link to postu

Miałem na myśli, aby zmienić w kodzie wydruku sposób sortowania. Widzę, że sam wydruk dość zaawansowany w środku (ukłony dla @Ks. Robak :) )

Nie uruchamiałem go u siebie, ale jeśli ktoś odważny i nie boi się kodu C#, to proponuję zrobić kopię oryginalnego wydruku, a następnie wybierając Page header z eksploratora po prawej trzeba otworzyć we właściwościach na dole Scripts i tam Before Print

 

obraz.png.09e9dd29074beb42022179490f175ed2.png

Następnie odnaleźć poniższy fragment kodu:

 

public class ProductComparer:IComparer<Product>
    {
        public int Compare(Product twA, Product twB)
        {        
            if (twA.OwnFieldWarehouseValue.CompareTo(twB.OwnFieldWarehouseValue) > 0) return 1;
            if (twA.OwnFieldWarehouseValue.CompareTo(twB.OwnFieldWarehouseValue) < 0) return -1;
            if (twA.OwnFieldWarehouseValue.CompareTo(twB.OwnFieldWarehouseValue) == 0)
            {
                if (twA.OwnFieldShelfValue.CompareTo(twB.OwnFieldShelfValue) > 0) return 1;
                if (twA.OwnFieldShelfValue.CompareTo(twB.OwnFieldShelfValue) < 0) return -1;
                if (twA.OwnFieldShelfValue.CompareTo(twB.OwnFieldShelfValue) == 0)
                {
                    if (twA.Name.CompareTo(twB.Name) > 0) return 1;
                    if (twA.Name.CompareTo(twB.Name) < 0) return -1;
                    if (twA.Name.CompareTo(twB.Name) == 0)
                    {
                        if (twA.Symbol.CompareTo(twB.Symbol) > 0) return 1;
                        if (twA.Symbol.CompareTo(twB.Symbol) < 0) return -1;
                    }
                }
            }
            return 0;

        }
    }

I tuż przed nim (przed public class....) dokleić poniższy:

public class AlphaNumericProductComparer:IComparer<Product>
    {
        public int Compare(Product twA, Product twB)
        {        
            string A = twA.OwnFieldWarehouseValue.PadLeft(5, '0');
            string B = twB.OwnFieldWarehouseValue.PadLeft(5, '0');
            if (A>B ) return 1;
            else if (A < B ) return -1;
            else
            {
                string shelfA = twA.OwnFieldShelfValue.PadLeft(5, '0');
                string shelfB = twB.OwnFieldShelfValue.PadLeft(5, '0');
                if (shelfA > shelfB) return 1;
                else if (shelfA < shelfB) return -1;
                else 
                {
                    if (twA.Name.CompareTo(twB.Name) > 0) return 1;
                    if (twA.Name.CompareTo(twB.Name) < 0) return -1;
                    if (twA.Name.CompareTo(twB.Name) == 0)
                    {
                        if (twA.Symbol.CompareTo(twB.Symbol) > 0) return 1;
                        if (twA.Symbol.CompareTo(twB.Symbol) < 0) return -1;
                    }
                }
            }
            return 0;
        }
    }

To jest inna wersja porównywacza wartości magazynu i półki, która przed porównaniem obu wartości dostawia sobie do nich po lewej stronie wiodące 0, tak aby wyszło 5 znaków. Zatem półka 34 zmieni się na 00034 a 134 na 00134 i ich porównanie zadziałać powinno poprawnie liczbowo. Jeśli dodatkowo będą znaki typu 34e, 34b, to również zostaną prawidłowo porównane jako 0034b, 0034e. Jesli ktoś potrzebuje więcej niż 5 znaków, to można podmienić w kodzie w okolicach funkcji PadLeft(5, '0') na PadLeft(10, '0').

 

Dodatkowo, aby kod zadziałał, trzeba jeszcze odnaleźć poniższy fragment i wstawić zaznaczoną linię:

UniqueProducts uniquePr;
ProductToProductDbResultMapper mapper;
ProductComparer prComparer;
AlphaNumericProductComparer anComparer; // <--- tutaj dodać porównywacz alfanumeryczny
ProductSorter prSorter;
SQLErrorMessage sqlErrorMsg;
DataRecordToProductDbResultMapper mapperDbRecord;
ProductDataStoreSelloSQLSrv sello;
ProductDataStoreSubiektGTSQLSrv subiektGT;

oraz kilka linii niżej:

uniquePr = new UniqueProducts();
mapper = new ProductToProductDbResultMapper();
anComparer = new AlphaNumericProductComparer(); // <-- tutaj dodać porównywacz alfanumeryczny
//prComparer= new ProductComparer();  			// <-- tutaj można dodać // na początku
//prSorter = new ProductSorter(prComparer);		// <--  tutaj zamienić prComparer na anComparer
prSorter = new ProductSorter(anComparer); 		// <-- albo dodać tę linijkę a powyższą wyłączyć za pomocą //
sqlErrorMsg = new SQLErrorMessage();
mapperDbRecord = new DataRecordToProductDbResultMapper();
sello = new ProductDataStoreSelloSQLSrv(sqlErrorMsg, mapperDbRecord);
subiektGT = new ProductDataStoreSubiektGTSQLSrv(sqlErrorMsg, mapperDbRecord);

To spowoduje, że zamiast istniejącego porównywacza magazynu i półki zostanie użyty ten dodany powyżej alfanumeryczny. Kod nie był sprawdzany, pisany na kolanie, ale powinien zadziałać. Najlepiej jakby @Ks. Robak go zweryfikował i zaadaptował do swojego wydruku :).

 

 

 

Link to postu

Przy okazji jeszcze jedno zagadnienie do tego tematu. Czy jest możliwość edycji danych z "Source Binding" (Kontrolka->Dane->Bindings->Text->Binding) w taki sposób, żeby zmodyfikować te dane pod kątem usunięcia pewnej powtarzającej się wartości.

 

Przykładowo, źródło danych ("Dokument") zwraca:

FV 10/12/001

FV 10/12/002

FV 10/12/003

FV 10/12/004

FV 10/12/005

itd.

 

Chciałbym zastosować coś takiego

"[Dokument]".Replace("FV","Faktura")

, co w wyniku by dało:

Faktura 10/12/001

Faktura 10/12/002

Faktura 10/12/003

Faktura 10/12/004

Faktura 10/12/005

itd.

 

Nie wiem jaka jest wersja raportów w Sello, ale wygląda na starszą. W nowej wersji jest dodatkowa opcja edycji "Source Binding" z poziomu edytora:

xrbinding.jpg.d7d426876bb42d5e5ad7667e88956e14.jpg

Jeżeli w raportach z Sello nie ma takiej możliwości, to w jaki sposób można by było tego dokonać z poziomu kodu? Może Bartek @Bartosz Rosa coś doradzi :)

Link to postu

Można to zrobić z poziomu skryptu BeforePrint dla danej kontrolki. Zamiast bindować pole bezpośrednio do kontrolki, w skrypcie można ustawić wartość Text kontrolki.

 

public void OnBeforePrint(object sender, System.Drawing.Printing.PrintEventArgs e) 
{
 	XRControl control = (XRControl)sender;
	string value = xtraReport1.GetCurrentColumnValue("Paczka_NrFaktury").ToString();
  	control.Text = value.Replace("FV", "Faktura");
}

 

  • Lubię to 1
Link to postu

Jeszcze jedno pytanie do Bartka @Bartosz Rosa. Czy jest możliwość aby obsłużyć notatki w ten sposób, żeby w raporcie wyświetlić ostatnią dodaną notatkę (przez użytkownika Sello, nie klienta) do paczki? W testowym raporcie po prostu wrzucone jest pole "Paczka_Notatki" do kontrolki i w podglądzie daje to wynik "Notatka testowa...". Natomiast nie pojawiają się żadne informacje w podglądzie raportu do realnych paczek, które notatki posiadają.

 

Pytanie też pojawia się takie, jak rozróżnić notatki użytkowników z poziomu raportów między tymi, które pochodzą od klientów? W programie, te od klientów dodawane są przez użytkownika (przypisanego do serwera), natomiast te dodane "ręcznie" pochodzą od konkretnego człowieka obsługującego program i przypisanego do niego użytkownika. Gdyby w raportach dało się wyciągnąć ostatnią taką notatkę w paczce od użytkownika - człowieka i umieścić ją w kontrolce, to byłoby to czego szukamy :)

Edytowane przez Jakub ***
Link to postu
Godzinę temu, Jakub *** napisał:

Natomiast nie pojawiają się żadne informacje w podglądzie raportu do realnych paczek, które notatki posiadają.

Notatki te muszą mieć zaznaczony pstryczek Wydruk, aby pojawiły się w tym polu. Żeby się to samo zaznaczało trzeba dodać sobie szablon notatki z zaznaczonym znacznikiem Wydruk i oznaczyć taką notatkę jako domyślna.

Mając już wszystkie notatki oznaczone do wydruku, trzeba by było skryptem przetworzyć tę listę tak, aby wyświetliła się tylko ta od klienta albo dodana przez użytkownika.

  • Dziękuję 1
Link to postu
  • 4 tygodnie później...
using System.Data;
using System.Collections.Generic;
using System;
using System.Text;
using System.IO;
using System.Data.SqlClient;

public interface IDataRecordToProductDbResultMapper
    {
        void Map(IDataRecord record, ProductDbResult productResult);
    }

public enum OwnFieldType
    {
        selloInternal, selloExternal
    }

public interface IOwnField
    {
        string Name { get; set; }
        string Value { get; set; }
        OwnFieldType Type { get; set; }

    }

public interface IProductDataStore
    {
        List<ProductDbResult> GetProductsDataBySymbol(List<string> symbols);
        List<ProductDbResult> GetProductsDataByName(List<string> names);
        bool CheckDbCompatibility();
        string LoginSQL { get; set; }
        string HasloSQL { get; set; }
        string InstancjaSQL { get; set; }
        string BazaDanychSQL { get; set; }
        bool AutentykacjaWindows { get; set; }
        string MagazynNazwaPolaWlasnego { get; set; }
        string PolkaMagazynowaNazwaPolaWlasnego { get; set; }
        string UwagiNazwaPolaWlasnego { get; set; }
        int CommandTimeout { get; set; }
        int ConnectionTimeout { get; set; }
        int ImageOrderNumber { get; set; }
        bool IsSqlError();
        string SqlErrorText();
    }

public interface IProductDbMapper
    {
        void Map(Product pr, List<ProductDbResult> record);
    }


public interface IProductOwnFieldMapper
    {
        string Map(ProductOwnFieldType ownFieldType);
    }

public interface IProductSorter
    {
        List<Product> Sort(List<Product> products);
    }

public interface IUniqueProducts
    {
        decimal TotalCount { get; set; }

        void Add(Product product);
        List<Product> GetProducts();
        void Sort(IProductSorter sorter);
	int ProductCount { get; }
    }

public class DataRecordToProductDbResultMapper : IDataRecordToProductDbResultMapper
    {
        public DataRecordToProductDbResultMapper()
        {

        }

        public void Map (IDataRecord record, ProductDbResult productResult)
        {
            for (int i=0; i<record.FieldCount;i++)
            {
                switch (record.GetName(i))
                {
                    case "name":
                        if (!DBNull.Value.Equals(record[i]))
                        {
                            productResult.Name = record.GetString(i);
                        }
                        break;
                    case "symbol":
                        if (!DBNull.Value.Equals(record[i]))
                        {
                            productResult.Symbol = record.GetString(i);
                        }
                        break;
                    case "idSello":
                        if (!DBNull.Value.Equals(record[i]))
                        {
                            productResult.IdSello = record.GetInt32(i);
                        }
                        break;
                    case "obrazek":
                        if (!DBNull.Value.Equals(record[i]) && ((byte[])record[i]).Length > 0)
                        {
                            productResult.Image = new MemoryStream((byte[])record[i]);
                        }
                        break;
                    case "price":
                        if (!DBNull.Value.Equals(record[i]))
                        {
                            productResult.Price = record.GetDecimal(i);
                        }
                        break;
                    case "weight":
                        if (!DBNull.Value.Equals(record[i]))
                        {
                            productResult.Weight = record.GetDecimal(i);
                        }
                        break;
                    case "ownFieldSelloExtName":
                        if (!DBNull.Value.Equals(record[i]))
                        {
                            string value = record["ownFieldSelloExtValue"].ToString();
                            productResult.OwnFieldSelloExtName = record.GetString(i);
                            productResult.OwnFieldSelloExtValue = value;
                        }
                        break;

                    case "MetricUnit":
                        if (!DBNull.Value.Equals(record[i]))
                        {
                            productResult.MetricUnit = record.GetString(i);
                        }
                        break;

                    default:
                        break;
                }
            }
        }
    }

public enum ProductOwnFieldType
    {
        Warehouse,
        Shelf,
        Notice
    }

public class ProductOwnFieldMapper : IProductOwnFieldMapper
    {
        string OwnFieldWarehouseName;
        string OwnFieldShelfName;
        string OwnFieldNoticeName;

        public ProductOwnFieldMapper(string OwnFieldWarehouseName, string OwnFieldShelfName, string OwnFieldNoticeName)
        {
            this.OwnFieldWarehouseName = OwnFieldWarehouseName;
            this.OwnFieldShelfName = OwnFieldShelfName;
            this.OwnFieldNoticeName = OwnFieldNoticeName;
        }

        public string Map(ProductOwnFieldType ownFieldType)
        {
            switch (ownFieldType)
            {
                case ProductOwnFieldType.Warehouse:
                    return OwnFieldWarehouseName;
                    
                case ProductOwnFieldType.Shelf:
                    return OwnFieldShelfName;

                case ProductOwnFieldType.Notice:
                    return OwnFieldNoticeName;

                default:
                    return string.Empty;

            }
        }
    }


public class ProductToProductDbResultMapper : IProductDbMapper
    {
        public void Map(Product pr, List<ProductDbResult> records)
        {            
            List<ProductDbResult> matchingRecords;
            if (string.IsNullOrEmpty(pr.Name)) throw new Exception("Wykryto produkt bez nazwy. Produkt musi posiadać nazwę");

            if (!string.IsNullOrEmpty(pr.Symbol))
            {
                matchingRecords=records.FindAll(delegate (ProductDbResult rec)
                {
                    if (!string.IsNullOrEmpty(rec.Symbol))
                    {
                        return (rec.Symbol.Equals(pr.Symbol) && pr.Name.Equals(rec.Name));
                    }
                    return false;

                });   
            }
            else
            {
                if (!string.IsNullOrEmpty(pr.Name))
                {
                    matchingRecords = records.FindAll(delegate (ProductDbResult rec)
                    {
                        if (!string.IsNullOrEmpty(rec.Name))
                        {
                            return (rec.Name.Equals(pr.Name) && string.IsNullOrEmpty(rec.Symbol));
                        }
                        return false;
                    });
                    foreach (ProductDbResult record in matchingRecords)
                    {
                        if (!string.IsNullOrEmpty(record.Symbol)) throw new Exception("Produkt bez symbolu posiada symbol");
                    }
                }
                else throw new Exception("Produkt bez symbolu i nazwy");
            }
            if (matchingRecords.Count > 0)
            {
                foreach (ProductDbResult record in matchingRecords)
                {                    
                    if (record.IdSello.HasValue) pr.DbId = (int)record.IdSello;
                    if (record.Price.HasValue) pr.Price = (decimal)record.Price;
                    if (record.Weight.HasValue) pr.Weight = (decimal)record.Weight;
                    if (!string.IsNullOrEmpty(record.OwnFieldSelloExtName))
                    {
                        if (!string.IsNullOrEmpty(record.OwnFieldSelloExtValue)) pr.AddOwnField(pr.CreateOwnField(record.OwnFieldSelloExtName, record.OwnFieldSelloExtValue, OwnFieldType.selloExternal));
                    }
                    if (record.Image.Length > 0) pr.Image = record.Image;
                    if (!string.IsNullOrEmpty(record.MetricUnit)) pr.JednMiarySprzedSubiekt = record.MetricUnit;
                }

            }            
        }
    }

class OwnField : IOwnField
    {
        private string _Value;

        public string Value
        {
            get { return _Value; }
            set { _Value = value; }
        }

        private string _Name;

        public string Name
        {
            get { return _Name; }
            set { _Name = value; }
        }

        private OwnFieldType _Type;

        public OwnFieldType Type
        {
            get { return _Type; }
            set { _Type = value; }
        }

        
    }

public class Product
    {
        private int _dbId;
        public int DbId  { get { return _dbId; } set { _dbId = value; } }

        private string _Name;
        public string Name { get { return _Name; } set { _Name = value; } }

        private string _Symbol;
        public string Symbol { get { return _Symbol; } set { _Symbol = value; } }

        private decimal _Count;
        public decimal Count { get { return _Count; } set { _Count = value; } }

        private MemoryStream _Image;
        public MemoryStream Image { get { return _Image; } set { _Image = value; } }

        private string _JednMiarySprzedSubiekt;
        public string JednMiarySprzedSubiekt { get { return _JednMiarySprzedSubiekt; } set { _JednMiarySprzedSubiekt = value; } }

        private decimal _Weight;
        public decimal Weight { get { return _Weight; } set { _Weight = value; } }

        private decimal _Price;
        public decimal Price { get { return _Price; } set { _Price = value; } }

        private List<IOwnField> ownFields;

        public string GetOwnFieldValue(string fieldName)
        {
            IOwnField result;
            result =ownFields.Find(delegate (IOwnField x) { return x.Name.Equals(fieldName); });
            if (result != null) return result.Value;
            return string.Empty;
        }

        IProductOwnFieldMapper ownFieldsMapper;
                   
        public string OwnFieldWarehouseValue { get { return GetOwnFieldValue(ownFieldsMapper.Map(ProductOwnFieldType.Warehouse)); }  }         
        public string OwnFieldShelfValue  { get { return GetOwnFieldValue(ownFieldsMapper.Map(ProductOwnFieldType.Shelf)); }}              
        public string OwnFieldNoticeValue { get { return GetOwnFieldValue(ownFieldsMapper.Map(ProductOwnFieldType.Notice)); } }

        public void AddOwnField(IOwnField ownField)
        {
            ownFields.Add(ownField);
        }

        public IOwnField CreateOwnField(string name, string value, OwnFieldType type)
        {
            IOwnField field= new OwnField();
            field.Name = name;
            field.Value = value;
            field.Type = type;
            return field;
        }


        public Product(IProductOwnFieldMapper mapper)
        {
            ownFields = new List<IOwnField>();
            Image = new MemoryStream(new byte[0]);
            ownFieldsMapper = mapper;
            Name = string.Empty;
            Symbol = string.Empty;
            JednMiarySprzedSubiekt = string.Empty;
        }

    }

public class AlphaNumericProductComparer:IComparer<Product>
    {
        public int Compare(Product twA, Product twB)
        {        
            string A = twA.OwnFieldWarehouseValue.PadLeft(2, '0');
            string B = twB.OwnFieldWarehouseValue.PadLeft(2, '0');
            if (A>B ) return 1;
            else if (A < B ) return -1;
            else
            {
                string shelfA = twA.OwnFieldShelfValue.PadLeft(5, '0');
                string shelfB = twB.OwnFieldShelfValue.PadLeft(5, '0');
                if (shelfA > shelfB) return 1;
                else if (shelfA < shelfB) return -1;
                else 
                {
                    if (twA.Name.CompareTo(twB.Name) > 0) return 1;
                    if (twA.Name.CompareTo(twB.Name) < 0) return -1;
                    if (twA.Name.CompareTo(twB.Name) == 0)
                    {
                        if (twA.Symbol.CompareTo(twB.Symbol) > 0) return 1;
                        if (twA.Symbol.CompareTo(twB.Symbol) < 0) return -1;
                    }
                }
            }
            return 0;
        }
    }

public class ProductComparer:IComparer<Product>
    {
        public int Compare(Product twA, Product twB)
        {        
            if (twA.OwnFieldWarehouseValue.CompareTo(twB.OwnFieldWarehouseValue) > 0) return 1;
            if (twA.OwnFieldWarehouseValue.CompareTo(twB.OwnFieldWarehouseValue) < 0) return -1;
            if (twA.OwnFieldWarehouseValue.CompareTo(twB.OwnFieldWarehouseValue) == 0)
            {
                if (twA.OwnFieldShelfValue.CompareTo(twB.OwnFieldShelfValue) > 0) return 1;
                if (twA.OwnFieldShelfValue.CompareTo(twB.OwnFieldShelfValue) < 0) return -1;
                if (twA.OwnFieldShelfValue.CompareTo(twB.OwnFieldShelfValue) == 0)
                {
                    if (twA.Name.CompareTo(twB.Name) > 0) return 1;
                    if (twA.Name.CompareTo(twB.Name) < 0) return -1;
                    if (twA.Name.CompareTo(twB.Name) == 0)
                    {
                        if (twA.Symbol.CompareTo(twB.Symbol) > 0) return 1;
                        if (twA.Symbol.CompareTo(twB.Symbol) < 0) return -1;
                    }
                }
            }
            return 0;

        }
    }


class ProductDataStoreSelloSQLSrv : IProductDataStore
    {
        SQLErrorMessage sqlError;

        private string _LoginSQL;
        public string LoginSQL { get { return _LoginSQL; } set { _LoginSQL = value; } }

        private string _HasloSQL;
        public string HasloSQL { get { return _HasloSQL; } set { _HasloSQL = value; } }

        private string _InstancjaSQL;
        public string InstancjaSQL { get { return _InstancjaSQL; } set { _InstancjaSQL = value; } }

        private string _BazaDanychSQL;
        public string BazaDanychSQL { get { return _BazaDanychSQL; } set { _BazaDanychSQL = value; } }

        private bool _AutentykacjaWindows;
        public bool AutentykacjaWindows { get { return _AutentykacjaWindows; } set { _AutentykacjaWindows = value; } }

        private string _MagazynNazwaPolaWlasnego;
        public string MagazynNazwaPolaWlasnego { get { return _MagazynNazwaPolaWlasnego; } set { _MagazynNazwaPolaWlasnego = value; } }

        private string _PolkaMagazynowaNazwaPolaWlasnego;
        public string PolkaMagazynowaNazwaPolaWlasnego { get { return _PolkaMagazynowaNazwaPolaWlasnego; } set { _PolkaMagazynowaNazwaPolaWlasnego = value; } }

        private string _UwagiNazwaPolaWlasnego;
        public string UwagiNazwaPolaWlasnego { get { return _UwagiNazwaPolaWlasnego; } set { _UwagiNazwaPolaWlasnego = value; } }

        private int pageSize;

        private int _cmdTimeout;

        public int CommandTimeout
        {
            get { return _cmdTimeout; }
            set { _cmdTimeout = value; }
        }

        private int _cnnTimeout;

        public int ConnectionTimeout
        {
            get { return _cnnTimeout; }
            set { _cnnTimeout = value; }
        }

        private int _imageOrderNumber;

        public int ImageOrderNumber
        {
            get { return _imageOrderNumber; }
            set { _imageOrderNumber = value; }
        }

        public bool IsSqlError() { return sqlError.wystapilBlad; }

        public string SqlErrorText() { return sqlError.bladTekst(); }


        IDataRecordToProductDbResultMapper mapper;



        public ProductDataStoreSelloSQLSrv(SQLErrorMessage msg, IDataRecordToProductDbResultMapper mapper)
        {
            sqlError = msg;
            pageSize = 50;
            CommandTimeout = 45;
            ConnectionTimeout = 45;
            this.mapper = mapper;
            ImageOrderNumber = 0;
        }

        private string GetConnectionString()
        {
            SqlConnectionStringBuilder sb = new SqlConnectionStringBuilder();
            sb.ConnectTimeout = ConnectionTimeout;
            sb.DataSource = InstancjaSQL;
            sb.Password = HasloSQL;
            sb.UserID = LoginSQL;            
            sb.InitialCatalog = BazaDanychSQL;
            return sb.ConnectionString;

        }

        public bool CheckDbCompatibility()
        {
            using (SqlConnection conn = new SqlConnection(GetConnectionString()))
            {
                try
                {
                    conn.Open();
                }
                catch (SqlException ex)
                {
                    sqlError.pobierzBlad(ex);
                    return false;
                }
                SqlCommand command = conn.CreateCommand();
                string sql = "SELECT TOP(1) it_id, it_Name, it_Symbol, it_Price, it_Weight FROM it__Item, st_Shipping, sl_PricingList";
                command.CommandText = sql;
                command.CommandTimeout = CommandTimeout;
                try
                {
                    using (SqlDataReader reader = command.ExecuteReader())
                    {
                        if (reader.Read()) return true;                        
                    }
                }
                catch (SqlException ex)
                {
                    sqlError.pobierzBlad(ex);
                }

            }
            return false;
        }

        public List<ProductDbResult> GetProductsDataBySymbol(List<string> symbols)
        {
            List<ProductDbResult> result = new List<ProductDbResult>();
            using (SqlConnection conn = new SqlConnection(GetConnectionString()))
            {          
                string sqlTowaryBezZdjec= @"SELECT it_id as idSello, q1.it_Name as name, q1.it_Symbol as symbol, it_Price as price, it_Weight as weight, ca_dict.ecd_SelloName as ownFieldSelloExtName, ca.eca_Value ownFieldSelloExtValue
                FROM (SELECT MIN(it_id) as min_it_id, it_Name, it_Symbol FROM  it__Item as product WHERE product.it_Symbol IN({0})  GROUP BY it_Symbol, it_Name) as q1
                LEFT JOIN it__Item as product2 ON q1.min_it_id = product2.it_id LEFT JOIN  it_ExternalCustomAttributes as ca
                ON ca.eca_ItemId = q1.min_it_id LEFT JOIN  it_ExternalCustomAttributesDict as ca_dict ON ca_dict.ecd_Id = ca.eca_AttributeId";
                List<int> idList = new List<int>();
                string sql;
                SqlParamsPaged<string> paged = new SqlParamsPaged<string>(pageSize);
                paged.Init(symbols.ToArray());
                try
                {
                    conn.Open();
                }
                catch (SqlException ex)
                {
                    sqlError.pobierzBlad(ex);
                    return result;
                }
                SqlCommand command = conn.CreateCommand();
                ProductDbResult productDbResult;
                while (paged.GetNextPage())
                {                    
                    SqlParamsPagedResult<string> pgResult = new SqlParamsPagedResult<string>();
                    paged.GetCurrentParams(pgResult);
                    sql = string.Format(sqlTowaryBezZdjec, pgResult.InClause);
                    command.CommandText = sql;
                    command.CommandTimeout = CommandTimeout;
                    for (int i = 0; i < pgResult.Count; i++)
                    {
                        command.Parameters.AddWithValue(pgResult.ParamTags[i], pgResult.ParamValues[i]);
                    }
                    try
                    {
                        using (SqlDataReader reader = command.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                productDbResult = new ProductDbResult();
                                mapper.Map(reader, productDbResult);
                                result.Add(productDbResult);
                                if (idList.IndexOf((int)reader["idSello"]) == -1)
                                {
                                    idList.Add((int)reader["idSello"]);
                                }
                            }
                        }
                    }
                    catch (SqlException ex)
                    {
                        sqlError.pobierzBlad(ex);
                        break;
                    }
                }
                result.AddRange(GetPicturesById(idList, conn));
            }
            return result;
            
        }

        private List<ProductDbResult> GetPicturesById(List<int> idList, SqlConnection conn)
        {
            SqlParamsPaged<int> pagedInt = new SqlParamsPaged<int>(pageSize);
            SqlCommand command = conn.CreateCommand();
            List<ProductDbResult> result = new List<ProductDbResult>();
            string sql;
            string sqlProductPicturesById = @"SELECT it_name as name, it_symbol as symbol, it_id as idSello, im_Image as obrazek, pc_PictureOrder as numerObrazka
                FROM it__item
                LEFT JOIN
                (SELECT pc_ItemId, pc_PictureId, pc_PictureOrder FROM it_ItemPictures WHERE pc_PictureOrder= {1}) as q1
                ON
                  it_id = q1.pc_ItemId
                LEFT JOIN im__Image
                  ON pc_PictureId = im_Id
                WHERE it_id IN({0})";
            pagedInt.Init(idList.ToArray());
            command = conn.CreateCommand();
            ProductDbResult productDbResult;
            while (pagedInt.GetNextPage())
            {
                SqlParamsPagedResult<int> pgResult = new SqlParamsPagedResult<int>();
                pagedInt.GetCurrentParams(pgResult);
                sql = string.Format(sqlProductPicturesById, pgResult.InClause, ImageOrderNumber);
                command.CommandText = sql;
                command.CommandTimeout = CommandTimeout;
                for (int i = 0; i < pgResult.Count; i++)
                {
                    command.Parameters.AddWithValue(pgResult.ParamTags[i], pgResult.ParamValues[i]);
                }
                try
                {
                    using (SqlDataReader reader = command.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            productDbResult = new ProductDbResult();
                            mapper.Map(reader, productDbResult);
                            result.Add(productDbResult);
                        }
                    }
                }
                catch (SqlException ex)
                {
                    sqlError.pobierzBlad(ex);
                }
            }
            return result;
        }

        public List<ProductDbResult> GetProductsDataByName(List<string> names)
        {
            List<ProductDbResult> result = new List<ProductDbResult>();
            using (SqlConnection conn = new SqlConnection(GetConnectionString()))
            {
                string sqlTowaryBezZdjec = @"SELECT it_id as idSello, q1.it_Name as name, q1.it_Symbol as symbol, it_Price as price, it_Weight as weight, ca_dict.ecd_SelloName as ownFieldSelloExtName, ca.eca_Value ownFieldSelloExtValue
                FROM (SELECT MIN(it_id) as min_it_id, it_Name, it_Symbol FROM  it__Item as product WHERE product.it_Name IN({0})  GROUP BY it_Symbol, it_Name) as q1
                LEFT JOIN it__Item as product2 ON q1.min_it_id = product2.it_id LEFT JOIN  it_ExternalCustomAttributes as ca
                ON ca.eca_ItemId = q1.min_it_id LEFT JOIN  it_ExternalCustomAttributesDict as ca_dict ON ca_dict.ecd_Id = ca.eca_AttributeId";

                string sql;
                List<int> idList = new List<int>();
                SqlParamsPagedString paged = new SqlParamsPagedString(pageSize);
                paged.Init(names.ToArray());
                try
                {
                    conn.Open();
                }
                catch (SqlException ex)
                {
                    sqlError.pobierzBlad(ex);
                    return result;
                }
                SqlCommand command = conn.CreateCommand();
                ProductDbResult productDbResult;
                while (paged.GetNextPage())
                {
                    SqlParamsPagedStringResult pgResult = new SqlParamsPagedStringResult();
                    paged.GetCurrentParams(pgResult);
                    sql = string.Format(sqlTowaryBezZdjec, pgResult.InClause);
                    command.CommandText = sql;
                    command.CommandTimeout = CommandTimeout;
                    for (int i = 0; i < pgResult.Count; i++)
                    {
                        command.Parameters.AddWithValue(pgResult.ParamTags[i], pgResult.ParamValues[i]);
                    }
                    try
                    {
                        using (SqlDataReader reader = command.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                productDbResult = new ProductDbResult();
                                mapper.Map(reader, productDbResult);
                                result.Add(productDbResult);
                                if (idList.IndexOf((int)reader["idSello"]) == -1)
                                {
                                    idList.Add((int)reader["idSello"]);
                                }
                            }
                        }
                    }
                    catch (SqlException ex)
                    {
                        sqlError.pobierzBlad(ex);
                    }
                }
                result.AddRange(GetPicturesById(idList, conn));
            }
            return result;

        }
    }

class ProductDataStoreSubiektGTSQLSrv : IProductDataStore
    {
        SQLErrorMessage sqlError;

        private string _LoginSQL;
        public string LoginSQL { get { return _LoginSQL; } set { _LoginSQL = value; } }

        private string _HasloSQL;
        public string HasloSQL { get { return _HasloSQL; } set { _HasloSQL = value; } }

        private string _InstancjaSQL;
        public string InstancjaSQL { get { return _InstancjaSQL; } set { _InstancjaSQL = value; } }

        private string _BazaDanychSQL;
        public string BazaDanychSQL { get { return _BazaDanychSQL; } set { _BazaDanychSQL = value; } }

        private bool _AutentykacjaWindows;
        public bool AutentykacjaWindows { get { return _AutentykacjaWindows; } set { _AutentykacjaWindows = value; } }

        private string _MagazynNazwaPolaWlasnego;
        public string MagazynNazwaPolaWlasnego { get { return _MagazynNazwaPolaWlasnego; } set { _MagazynNazwaPolaWlasnego = value; } }

        private string _PolkaMagazynowaNazwaPolaWlasnego;
        public string PolkaMagazynowaNazwaPolaWlasnego { get { return _PolkaMagazynowaNazwaPolaWlasnego; } set { _PolkaMagazynowaNazwaPolaWlasnego = value; } }

        private string _UwagiNazwaPolaWlasnego;
        public string UwagiNazwaPolaWlasnego { get { return _UwagiNazwaPolaWlasnego; } set { _UwagiNazwaPolaWlasnego = value; } }

        private int pageSize;

        private int _cmdTimeout;

        public int CommandTimeout
        {
            get { return _cmdTimeout; }
            set { _cmdTimeout = value; }
        }

        private int _cnnTimeout;

        public int ConnectionTimeout
        {
            get { return _cnnTimeout; }
            set { _cnnTimeout = value; }
        }

        private int _imageOrderNumber;

        public int ImageOrderNumber
        {
            get { return _imageOrderNumber; }
            set { _imageOrderNumber = value; }
        }

        public bool IsSqlError() { return sqlError.wystapilBlad; }

        public string SqlErrorText() { return sqlError.bladTekst(); }


        IDataRecordToProductDbResultMapper mapper;



        public ProductDataStoreSubiektGTSQLSrv(SQLErrorMessage msg, IDataRecordToProductDbResultMapper mapper)
        {
            sqlError = msg;
            pageSize = 50;
            CommandTimeout = 45;
            ConnectionTimeout = 45;
            this.mapper = mapper;
            ImageOrderNumber = 0;
        }

        private string GetConnectionString()
        {
            SqlConnectionStringBuilder sb = new SqlConnectionStringBuilder();
            sb.ConnectTimeout = ConnectionTimeout;
            sb.DataSource = InstancjaSQL;
            sb.Password = HasloSQL;
            sb.UserID = LoginSQL;            
            sb.InitialCatalog = BazaDanychSQL;
            return sb.ConnectionString;

        }

        public bool CheckDbCompatibility()
        {
            using (SqlConnection conn = new SqlConnection(GetConnectionString()))
            {
                try
                {
                    conn.Open();
                }
                catch (SqlException ex)
                {
                    sqlError.pobierzBlad(ex);
                    return false;
                }
                SqlCommand command = conn.CreateCommand();
                string sql = "SELECT top(1) gto_Id, gtd_Id, dzp_Id FROM gt__Obiekt, gt_Definicja, dekz_Pozycja";
                command.CommandText = sql;
                command.CommandTimeout = CommandTimeout;
                try
                {
                    using (SqlDataReader reader = command.ExecuteReader())
                    {
                        if (reader.Read()) return true;                        
                    }
                }
                catch (SqlException ex)
                {
                    sqlError.pobierzBlad(ex);
                }

            }
            return false;
        }

        public List<ProductDbResult> GetProductsDataBySymbol(List<string> symbols)
        {
            List<ProductDbResult> result = new List<ProductDbResult>();
            using (SqlConnection conn = new SqlConnection(GetConnectionString()))
            {          
                string sqlTowaryBezZdjec= @"SELECT tw.tw_Symbol as symbol,tw.tw_Nazwa as name, tw.tw_JednMiarySprz as MetricUnit FROM tw__Towar as tw 
                                    WHERE tw_Symbol IN ({0}) AND tw.tw_Usuniety=0;";
                List<int> idList = new List<int>();
                string sql;
                SqlParamsPaged<string> paged = new SqlParamsPaged<string>(pageSize);
                paged.Init(symbols.ToArray());
                try
                {
                    conn.Open();
                }
                catch (SqlException ex)
                {
                    sqlError.pobierzBlad(ex);
                    return result;
                }
                SqlCommand command = conn.CreateCommand();
                ProductDbResult productDbResult;
                while (paged.GetNextPage())
                {                    
                    SqlParamsPagedResult<string> pgResult = new SqlParamsPagedResult<string>();
                    paged.GetCurrentParams(pgResult);
                    sql = string.Format(sqlTowaryBezZdjec, pgResult.InClause);
                    command.CommandText = sql;
                    command.CommandTimeout = CommandTimeout;
                    for (int i = 0; i < pgResult.Count; i++)
                    {
                        command.Parameters.AddWithValue(pgResult.ParamTags[i], pgResult.ParamValues[i]);
                    }
                    try
                    {
                        using (SqlDataReader reader = command.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                productDbResult = new ProductDbResult();
                                mapper.Map(reader, productDbResult);
                                result.Add(productDbResult);                                
                            }
                        }
                    }
                    catch (SqlException ex)
                    {
                        sqlError.pobierzBlad(ex);
                        break;
                    }
                }
            }
            return result;
            
        }

        
        public List<ProductDbResult> GetProductsDataByName(List<string> names)
        {
            List<ProductDbResult> result = new List<ProductDbResult>();            
            return result;
        }
    }


public class ProductDbResult
    {
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        private string _symbol;

        public string Symbol
        {
            get { return _symbol; }
            set { _symbol = value; }
        }

        private int? _idSello;

        public int? IdSello
        {
            get { return _idSello; }
            set { _idSello = value; }
        }

        private decimal? _price;

        public decimal? Price
        {
            get { return _price; }
            set { _price = value; }
        }

        private decimal? _weight;

        public decimal? Weight
        {
            get { return _weight; }
            set { _weight = value; }
        }

        private string _ownFieldSelloExtName;

        public string OwnFieldSelloExtName
        {
            get { return _ownFieldSelloExtName; }
            set { _ownFieldSelloExtName = value; }
        }

        private string _ownFieldSelloExtValue;

        public string OwnFieldSelloExtValue
        {
            get { return _ownFieldSelloExtValue; }
            set { _ownFieldSelloExtValue = value; }
        }

        private MemoryStream _image;

        public MemoryStream Image
        {
            get { return _image; }
            set { _image = value; }
        }

        private string _metricUnit;

        public string MetricUnit
        {
            get { return _metricUnit; }
            set { _metricUnit = value; }
        }


        public ProductDbResult()
        {
            Image = new MemoryStream();
        }


    }


public class Products
    {
        IUniqueProducts uniqueProducts;
        List<IProductDataStore> dataStores;
        IProductDbMapper productMapper;
        IProductSorter sorter;
        IProductOwnFieldMapper ownFieldMapper;

        public Products(IUniqueProducts unProd, IProductDbMapper productMapper, IProductSorter sorter, IProductOwnFieldMapper ownFieldMapper)
        {
            uniqueProducts = unProd;
            dataStores = new List<IProductDataStore>();
            this.productMapper = productMapper;
            this.sorter = sorter;
            this.ownFieldMapper = ownFieldMapper;
        }

        public Product CreateProduct()
        {
            return new Product(ownFieldMapper);
        }

        private void Sort()
        {
            uniqueProducts.Sort(sorter);
        }

        public void AddProduct(string symbol, string name, decimal price, decimal count)
        {
            Product pr = CreateProduct();
            pr.Symbol = symbol;
            pr.Name = name;
            pr.Price = price;
            pr.Count = count;
            uniqueProducts.Add(pr);
        }

        public bool IsSqlError()
        {
            foreach (IProductDataStore store in dataStores)
            {
                if (store.IsSqlError()) return true;
            }
            return false;
        }

        public string SqlErrorText()
        {
            StringBuilder result=new StringBuilder();
            foreach (IProductDataStore store in dataStores)
            {
                if (store.IsSqlError())
                {
                    result.Append(store.SqlErrorText());
                }
            }
            return result.ToString();
        }

        public bool CheckDbCompatibility()
        {
            foreach (IProductDataStore store in dataStores)
            {
                if (store.CheckDbCompatibility()) continue;
                if (store.IsSqlError()) return false;
            }
            return true;
        }

        public void FillProductData()
        {
            List<List<ProductDbResult>> 
                symbolDataRecords=new List<List<ProductDbResult>>(), 
                nameDataRecords=new List<List<ProductDbResult>>();
            List<string> symbols;
            List<string> names;
            symbols = GetProductSymbols(GetProductsWithSymbols());
            names = GetProductNames(GetProductsWithoutSymbols());            
            foreach(IProductDataStore store in dataStores)
            {
                symbolDataRecords.Add(store.GetProductsDataBySymbol(symbols));
                if (store.IsSqlError()) return;
                nameDataRecords.Add(store.GetProductsDataByName(names));
                if (store.IsSqlError()) return;
            }
            foreach (Product product in uniqueProducts.GetProducts())
            {
                foreach (List<ProductDbResult> record in symbolDataRecords)
                {
                    productMapper.Map(product, record);
                }
                foreach (List<ProductDbResult> record in nameDataRecords)
                {
                    productMapper.Map(product, record);
                }
            }
            Sort();
        }

        public void AddDataStore(IProductDataStore store)
        {
            dataStores.Add(store);
        }

        public List<Product> GetProductsWithSymbols()
        {
            List<Product> tempProductsWithSymbols = new List<Product>();
            foreach (Product pr in uniqueProducts.GetProducts())
            {
                if (!string.IsNullOrEmpty(pr.Symbol))
                {
                    tempProductsWithSymbols.Add(pr);
                    
                }               
            }
            return tempProductsWithSymbols;
        }

        public List<Product> GetProductsWithoutSymbols()
        {
            List<Product> tempProductsWithoutSymbols = new List<Product>();
            foreach (Product pr in uniqueProducts.GetProducts())
            {
                if (string.IsNullOrEmpty(pr.Symbol))
                {
                    tempProductsWithoutSymbols.Add(pr);
                   
                }
            }
            return tempProductsWithoutSymbols;
        }

        public List<string> GetProductSymbols(List<Product> products)
        {
            List<string> tempProductSymbols = new List<string>();            
            foreach (Product pr in products)
            {
                if (!tempProductSymbols.Exists(delegate (string s) { return s.Equals(pr.Symbol); }))
                {
                    tempProductSymbols.Add(pr.Symbol);
                }
            }
            return tempProductSymbols;
        }

        public List<string> GetProductNames(List<Product> products)
        {
            List<string> tempProductNames = new List<string>();
            foreach (Product pr in products)
            {
                if (!tempProductNames.Exists(delegate (string s) { return s.Equals(pr.Name); }))
                {
                    tempProductNames.Add(pr.Name);
                }
            }
            return tempProductNames;
        }

        public IUniqueProducts GetAllProducts()
        {
            return uniqueProducts;
        }

    }

public class ProductSorter : IProductSorter
    {
        IComparer<Product> comparer;
        public ProductSorter(IComparer<Product> comparer)
        {
            this.comparer = comparer;
        }

        public List<Product> Sort(List<Product> products)
        {
            products.Sort(comparer);
            return products;
        }
    }

public class SQLErrorMessage
    {
        StringBuilder errorMessages=new StringBuilder();
        public bool wystapilBlad;
        public SQLErrorMessage()
        {
            wystapilBlad=false;
        }
        
        public void pobierzBlad(SqlException ex)
        {
            for (int i = 0; i < ex.Errors.Count; i++)
            {
                errorMessages.Append("Index #" + i + "\n" +
                    "SQL Wiadomosc: " + ex.Errors[i].Message + "\n" +
                    "SQL wiersz numer: " + ex.Errors[i].LineNumber + "\n" +
                    "Zrodlo: " + ex.Errors[i].Source + "\n" +
                    "SQL Procedura: " + ex.Errors[i].Procedure + "\n");
            }
            wystapilBlad = true;
        }

        public string bladTekst() { return errorMessages.ToString(); }
    }

public class SqlParamsPagedStringResult
    {
        private string[] _paramValues;

        public string[] ParamValues
        {
            get { return _paramValues; }
            set { _paramValues = value; }
        }

        private string[] _paramTags;

        public string[] ParamTags
        {
            get { return _paramTags; }
            set { _paramTags = value; }
        }

        private string _inClause;

        public string InClause
        {
            get { return _inClause; }
            set { _inClause = value; }
        }

        private int _numberOfResults;

        public int Count
        {
            get { return _numberOfResults; }
            set { _numberOfResults = value; }
        }

    }

    public class SqlParamsPagedString
    {
        int pageSize;
        int currentPage;
        int paramsCount;
        private int _TotalPages;
              
        public int TotalPages
        {
            get { return _TotalPages; }
            set { _TotalPages = value; }
        }

        private string _tagPrefix;

        public string TagPrefix
        {
            get { return _tagPrefix; }
            set { _tagPrefix = value; }
        }


        public int CurrentPage
        {
            get
            {
                return currentPage;
            }

            set
            {
                currentPage = value;
            }
        }

        string[] paramValues;

        public SqlParamsPagedString(int pageSize)
        {
            if (pageSize <= 0) throw new ArgumentException("Wartość pageSize powinna być >0");
            this.pageSize = pageSize;
            TagPrefix = "@tagSqlParamsPaged";
        }

        public void Init(string[] paramValues)
        {
            this.paramValues = paramValues;
            CurrentPage = 0;
            this.paramsCount = paramValues.Length;
            double d=0;
            if (paramsCount > 0)
            {
                d = (double)paramsCount / pageSize;
                TotalPages = (int)Math.Ceiling(d);
            }
            else TotalPages = 0;
        }

        public bool GetNextPage()
        {
            if (CurrentPage < TotalPages)
            {
                CurrentPage++;
                return true;
            }
            return false;
        }

        public void GetCurrentParams(SqlParamsPagedStringResult result)
        {
            int numberOfResults;
            if ((pageSize * CurrentPage <= paramsCount)) numberOfResults = pageSize;
            else numberOfResults = (paramsCount - (pageSize * (CurrentPage - 1)));
            result.ParamTags = new string[numberOfResults];
            result.ParamValues = new string[numberOfResults];
            result.Count = numberOfResults;
            int iterationStart = (CurrentPage-1) * pageSize;
            for (int i=0; i<numberOfResults; i++)
            {
                result.ParamTags[i] = TagPrefix + (i+iterationStart+1).ToString();
                result.ParamValues[i] = paramValues[i + iterationStart];
            }
            result.InClause = string.Join(",", result.ParamTags);
        }
    }

public class SqlParamsPagedResult<T>
    {
        private T[] _paramValues;

        public T[] ParamValues
        {
            get { return _paramValues; }
            set { _paramValues = value; }
        }

        private string[] _paramTags;

        public string[] ParamTags
        {
            get { return _paramTags; }
            set { _paramTags = value; }
        }

        private string _inClause;

        public string InClause
        {
            get { return _inClause; }
            set { _inClause = value; }
        }

        private int _numberOfResults;

        public int Count
        {
            get { return _numberOfResults; }
            set { _numberOfResults = value; }
        }

    }

    public class SqlParamsPaged<T>
    {
        int pageSize;
        int currentPage;
        int paramsCount;
        private int _TotalPages;
              
        public int TotalPages
        {
            get { return _TotalPages; }
            set { _TotalPages = value; }
        }

        private string _tagPrefix;

        public string TagPrefix
        {
            get { return _tagPrefix; }
            set { _tagPrefix = value; }
        }


        public int CurrentPage
        {
            get
            {
                return currentPage;
            }

            set
            {
                currentPage = value;
            }
        }

        T[] paramValues;

        public SqlParamsPaged(int pageSize)
        {
            if (pageSize <= 0) throw new ArgumentException("Wartość pageSize powinna być >0");
            this.pageSize = pageSize;
            TagPrefix = "@tagSqlParamsPaged";
        }

        public void Init(T[] paramValues)
        {
            this.paramValues = paramValues;
            CurrentPage = 0;
            this.paramsCount = paramValues.Length;
            double d=0;
            if (paramsCount > 0)
            {
                d = (double)paramsCount / pageSize;
                TotalPages = (int)Math.Ceiling(d);
            }
            else TotalPages = 0;
        }

        public bool GetNextPage()
        {
            if (CurrentPage < TotalPages)
            {
                CurrentPage++;
                return true;
            }
            return false;
        }

        public void GetCurrentParams(SqlParamsPagedResult<T> result)
        {
            int numberOfResults;
            if ((pageSize * CurrentPage <= paramsCount)) numberOfResults = pageSize;
            else numberOfResults = (paramsCount - (pageSize * (CurrentPage - 1)));
            result.ParamTags = new string[numberOfResults];
            result.ParamValues = new T[numberOfResults];
            result.Count = numberOfResults;
            int iterationStart = (CurrentPage-1) * pageSize;
            for (int i=0; i<numberOfResults; i++)
            {
                result.ParamTags[i] = TagPrefix + (i+iterationStart+1).ToString();
                result.ParamValues[i] = paramValues[i + iterationStart];
            }
            result.InClause = string.Join(",", result.ParamTags);
        }
    }

public class UniqueProducts: IUniqueProducts
    {
        List<Product> list;
        private decimal _SumaIlosci;
        public decimal TotalCount { get { return _SumaIlosci; } set { _SumaIlosci = value; } }
        public void Add(Product product)
        {
            foreach (Product tw in list)
            {
                if ((tw.Symbol == product.Symbol) && (tw.Name==product.Name))
                {
                    TotalCount = TotalCount + product.Count;
                    tw.Count +=  product.Count;
                    if (tw.Price < product.Price) tw.Price = product.Price;
                    return;
                }
            }
            list.Add(product);
            TotalCount = TotalCount + product.Count;
        }

	public int ProductCount { get { return list.Count; } }

        public List<Product> GetProducts()
        {
            return list;
        }

        public void Sort(IProductSorter sorter)
        {
            list = sorter.Sort(list);
        }

        public UniqueProducts()
        {
            list = new List<Product>();
        }
        
    }


UniqueProducts uniquePr;
ProductToProductDbResultMapper mapper;
ProductComparer prComparer;
ProductSorter prSorter;
SQLErrorMessage sqlErrorMsg;
DataRecordToProductDbResultMapper mapperDbRecord;
ProductDataStoreSelloSQLSrv sello;
ProductDataStoreSubiektGTSQLSrv subiektGT;

ProductOwnFieldMapper prOwMapper;

Products ps;

Product product1;

#pragma warning disable 168

private void OnBeforePrint(object sender, System.Drawing.Printing.PrintEventArgs e) {

uniquePr = new UniqueProducts();
mapper = new ProductToProductDbResultMapper();
//prComparer= new ProductComparer();
prSorter = new ProductSorter(anComparer);
sqlErrorMsg = new SQLErrorMessage();
mapperDbRecord = new DataRecordToProductDbResultMapper();
sello = new ProductDataStoreSelloSQLSrv(sqlErrorMsg, mapperDbRecord);
subiektGT = new ProductDataStoreSubiektGTSQLSrv(sqlErrorMsg, mapperDbRecord);

prOwMapper = new ProductOwnFieldMapper(NazwaPolaWlasnegoZNazwaMagazynu, NazwaPolaWlasnegoZNazwaPolki, NazwaPolaWlasnegoZUwagami);

ps = new Products(uniquePr, mapper,prSorter,prOwMapper);


try
{
	sello.AutentykacjaWindows = SelloAutentykacjaWindows;
	sello.BazaDanychSQL = SelloSQLNazwaBazyDanych;
	sello.HasloSQL = SelloSQLHaslo;
	sello.LoginSQL = SelloSQLLogin;
	sello.InstancjaSQL = SelloNazwaInstancjiSQLServer;
	sello.ImageOrderNumber=SelloNumerObrazka-1;
	bool test=SelloPokazujCene;
}

catch(Exception ex)
	{
		labelBlad.Visible=true;
		labelBlad.Text="Błędny format danych konfiguracyjnych Sello. Proszę sprawdzić i poprawić.";		
		return;
	}

ps.AddDataStore(sello);
try
{
	if (KorzystajZBazyDanychSubiektaGT)
	{
		subiektGT.AutentykacjaWindows = SubiektGTAutentykacjaWindows;
	        subiektGT.BazaDanychSQL = SubiektGTSQLNazwaBazyDanych;
	        subiektGT.HasloSQL = SubiektGTSQLHaslo;
	        subiektGT.LoginSQL = SubiektGTSQLLogin;
	        subiektGT.InstancjaSQL = SubiektGTNazwaInstancjiSQLServer;
		ps.AddDataStore(subiektGT);
	}
}

catch(Exception ex)
	{
		labelBlad.Visible=true;
		labelBlad.Text="Błędny format danych konfiguracyjnych SubiektaGT. Proszę sprawdzić i poprawić.";		
		return;
	}
}

 

Link to postu
  • 3 tygodnie później...

Dołącz do dyskusji

Możesz dodać zawartość już teraz a zarejestrować się później. Jeśli posiadasz już konto, zaloguj się aby dodać zawartość za jego pomocą.

Gość
Odpowiedz...

×   Wklejono zawartość z formatowaniem.   Usuń formatowanie

  Dozwolonych jest tylko 75 emoji.

×   Odnośnik został automatycznie osadzony.   Przywróć wyświetlanie jako odnośnik

×   Przywrócono poprzednią zawartość.   Wyczyść edytor

×   Nie możesz bezpośrednio wkleić grafiki. Dodaj lub załącz grafiki z adresu URL.

×
×
  • Dodaj nową pozycję...