コード例 #1
0
ファイル: DataManager.cs プロジェクト: Guillemsc/SUMA
        private Producte GetProductePerCodiArticle(string codi_article)
        {
            Producte ret = null;

            for (int i = 0; i < productes.Count; ++i)
            {
                if (productes[i].codi_article == codi_article)
                {
                    ret = productes[i];
                    break;
                }
            }

            return(ret);
        }
コード例 #2
0
ファイル: DataManager.cs プロジェクト: Guillemsc/SUMA
        public void MakeEanProducteRelations()
        {
            for (int i = 0; i < productes.Count; ++i)
            {
                productes[i].codis_ean.Clear();
            }

            for (int i = 0; i < eans.Count; ++i)
            {
                Producte prod = GetProductePerCodiArticle(eans[i].codi_article);

                if (prod != null)
                {
                    prod.codis_ean.Add(eans[i]);

                    if (prod.primer_ean == "")
                    {
                        prod.primer_ean = eans[i].codi_ean;
                    }
                }
            }
        }
コード例 #3
0
ファイル: ParserManager.cs プロジェクト: Guillemsc/SUMA
        void ParseLine(string line)
        {
            Fitxer f = Managers.DataManager.Instance.GetFitxer();

            int cursor_pos = 0;

            line = line.Replace("\n", "");
            line = line.Replace("\r", "");

            if (line[cursor_pos] == 'C')
            {
                ParseCapçalera(line, cursor_pos);
            }

            if (line[cursor_pos] == 'L')
            {
                Producte prod = new Producte();

                ParseArticle(line, cursor_pos, ref prod);

                f.productes.Add(prod);
            }

            if (line[cursor_pos] == 'E')
            {
                CodiEan curr_ean = new CodiEan();

                ParseCodiEan(line, cursor_pos, ref curr_ean);

                f.eans.Add(curr_ean);
            }

            if (line[cursor_pos] == 'F')
            {
                ParseFinalFitxer(line, cursor_pos);

                f.MakeEanProducteRelations();
            }
        }
コード例 #4
0
ファイル: ParserManager.cs プロジェクト: Guillemsc/SUMA
        private void ParseArticle(string text, int cursor_pos, ref Producte prod)
        {
            cursor_pos += guide.tipus_registre;

            // Codi article ----------------------------------------------
            prod.codi_article = "";
            for (int i = 0; i < guide.producte_codi_article; ++i)
            {
                prod.codi_article += text[i + cursor_pos];
            }

            cursor_pos += guide.producte_codi_article;

            // Marca de baixa ---------------------------------------------
            prod.marca_de_baixa = guide.GetMarcaDeBaixa(text[cursor_pos]);

            cursor_pos += guide.marca_de_baixa;

            // Descripcio -------------------------------------------------
            for (int i = 0; i < guide.descripcio; ++i)
            {
                prod.descripcio += text[i + cursor_pos];
            }

            cursor_pos += guide.descripcio;

            // Unitats caixa ----------------------------------------------
            string unitats_caixa_str = "";

            for (int i = 0; i < guide.unitats_caixa; ++i)
            {
                unitats_caixa_str += text[i + cursor_pos];
            }

            int unitats_caixa = 0;

            int.TryParse(unitats_caixa_str, out unitats_caixa);
            prod.unitats_caixa = unitats_caixa;

            cursor_pos += guide.unitats_caixa;

            // Unitats fraccio --------------------------------------------
            string unitats_fraccio_str = "";

            for (int i = 0; i < guide.unitats_fraccio; ++i)
            {
                unitats_fraccio_str += text[i + cursor_pos];
            }

            int unitats_fraccio = 0;

            int.TryParse(unitats_fraccio_str, out unitats_fraccio);
            prod.unitats_fraccio = unitats_fraccio;

            cursor_pos += guide.unitats_fraccio;

            // Marca de pes -----------------------------------------------
            prod.marca_de_pes = guide.GetMarcaDePes(text[cursor_pos]);

            cursor_pos += guide.marca_pes;

            // Preu unitari -----------------------------------------------
            string preu_unitari_str        = "";
            string preu_unitari_enters_str = "";
            string preu_unitari_dec_str    = "";

            for (int i = 0; i < guide.preu_unitari; ++i)
            {
                if (i < 6)
                {
                    preu_unitari_enters_str += text[i + cursor_pos];
                }
                else
                {
                    preu_unitari_dec_str += text[i + cursor_pos];
                }
            }
            preu_unitari_str += preu_unitari_enters_str + "." + preu_unitari_dec_str;

            double preu_unitari = 0.0f;

            double.TryParse(preu_unitari_str, NumberStyles.Float, CultureInfo.InvariantCulture, out preu_unitari);
            prod.preu_unitari = preu_unitari;

            cursor_pos += guide.preu_unitari;

            // Preu venda public recomanat ---------------------------------
            string preu_venda_public_str        = "";
            string preu_venda_public_enters_str = "";
            string preu_venda_public_dec_str    = "";

            for (int i = 0; i < guide.preu_venda_public_recomanat; ++i)
            {
                if (i < 6)
                {
                    preu_venda_public_enters_str += text[i + cursor_pos];
                }
                else
                {
                    preu_venda_public_dec_str += text[i + cursor_pos];
                }
            }
            preu_venda_public_str += preu_venda_public_enters_str + "." + preu_venda_public_dec_str;

            double preu_venta_public_recomanat = 0.0f;

            double.TryParse(preu_venda_public_str, NumberStyles.Float, CultureInfo.InvariantCulture, out preu_venta_public_recomanat);
            prod.preu_venta_public_recomanat = preu_venta_public_recomanat;

            cursor_pos += guide.preu_venda_public_recomanat;

            // Preu de fraccio --------------------------------------------
            string preu_fraccio_str        = "";
            string preu_fraccio_enters_str = "";
            string preu_fraccio_dec_str    = "";

            for (int i = 0; i < guide.preu_fraccio; ++i)
            {
                if (i < 6)
                {
                    preu_fraccio_enters_str += text[i + cursor_pos];
                }
                else
                {
                    preu_fraccio_dec_str += text[i + cursor_pos];
                }
            }
            preu_fraccio_str += preu_fraccio_enters_str + "." + preu_fraccio_dec_str;

            double preu_de_fraccio = 0.0f;

            double.TryParse(preu_fraccio_str, NumberStyles.Float, CultureInfo.InvariantCulture, out preu_de_fraccio);
            prod.preu_de_fraccio = preu_de_fraccio;

            cursor_pos += guide.preu_fraccio;

            // Tipus d'iva -----------------------------------------------
            prod.tipus_iva = guide.GetTipusIva(text[cursor_pos]);

            cursor_pos += guide.tipus_iva;

            // Codi de familia -------------------------------------------
            string codi_familia_str = "";

            for (int i = 0; i < guide.codi_familia; ++i)
            {
                codi_familia_str += text[i + cursor_pos];
            }

            int codi_familia = 0;

            int.TryParse(codi_familia_str, out codi_familia);
            prod.codi_familia = codi_familia;

            cursor_pos += guide.codi_familia;


            // Codi de subfamilia -------------------------------------------
            string codi_subfamilia_str = "";

            for (int i = 0; i < guide.codi_sub_familia; ++i)
            {
                codi_subfamilia_str += text[i + cursor_pos];
            }

            int codi_sub_familia = 0;

            int.TryParse(codi_subfamilia_str, out codi_sub_familia);
            prod.codi_sub_familia = codi_sub_familia;

            cursor_pos += guide.codi_sub_familia;

            // Unitat de mesura ---------------------------------------------
            prod.unitats_mesura = guide.GetUnitatsMesura(text[cursor_pos]);

            cursor_pos += guide.unitat_de_mesura;

            // Factor de conversio ------------------------------------------
            string factor_de_conversio_str = "";

            for (int i = 0; i < guide.factor_de_conversio; ++i)
            {
                factor_de_conversio_str += text[i + cursor_pos];
            }

            double factor_de_conversio = 0.0f;

            double.TryParse(factor_de_conversio_str, NumberStyles.Float, CultureInfo.InvariantCulture, out factor_de_conversio);
            prod.factor_de_conversio = factor_de_conversio;

            cursor_pos += guide.factor_de_conversio;
        }
コード例 #5
0
ファイル: LocalDBManager.cs プロジェクト: Guillemsc/SUMA
        public bool LoadDataBase()
        {
            bool ret = false;

            if (connection != null)
            {
                Managers.DBManager.Instance.OpenConexion(connection);

                Fitxer f = DataManager.Instance.NewFitxer();

                OleDbCommand Cmd = new OleDbCommand("SELECT * FROM ArticlesMagsa", connection);

                OleDbDataReader data = Managers.DBManager.Instance.ExecuteReader(connection, Cmd);

                if (data != null)
                {
                    while (data.Read())
                    {
                        Producte prod = new Producte();

                        prod.codi_article                = data.GetString(1);
                        prod.marca_de_baixa              = ParserManager.Instance.guide.GetMarcaDeBaixa(data.GetString(2)[0]);
                        prod.descripcio                  = data.GetString(3);
                        prod.unitats_caixa               = Convert.ToInt32(data.GetValue(4));
                        prod.unitats_fraccio             = Convert.ToInt32(data.GetValue(5));
                        prod.marca_de_pes                = ParserManager.Instance.guide.GetMarcaDePes(data.GetString(6)[0]);
                        prod.preu_unitari                = data.GetDouble(7);
                        prod.preu_venta_public_recomanat = data.GetDouble(8);
                        prod.preu_de_fraccio             = data.GetDouble(9);
                        prod.tipus_iva        = ParserManager.Instance.guide.GetTipusIva(data.GetString(10)[0]);
                        prod.codi_familia     = Convert.ToInt32(data.GetValue(11));
                        prod.codi_sub_familia = Convert.ToInt32(data.GetValue(12));
                        prod.unitats_mesura   = ParserManager.Instance.guide.GetUnitatsMesura(data.GetString(13)[0]);
                        int factor_de_conversio = 0;
                        prod.factor_de_conversio = 0; int.TryParse(data.GetString(14), out factor_de_conversio);
                        prod.factor_de_conversio = factor_de_conversio;
                        prod.unitats_caixa       = Convert.ToInt32(data.GetValue(15));

                        f.productes.Add(prod);
                    }

                    data.Close();

                    ret = true;
                }

                OleDbCommand Cmd2 = new OleDbCommand("SELECT * FROM BarresMagsa", connection);

                OleDbDataReader data2 = Managers.DBManager.Instance.ExecuteReader(connection, Cmd2);

                if (data2 != null)
                {
                    while (data2.Read())
                    {
                        CodiEan ean = new CodiEan();

                        ean.codi_article = data2.GetString(1);
                        ean.codi_ean     = data2.GetString(2);

                        f.eans.Add(ean);
                    }

                    f.MakeEanProducteRelations();

                    data2.Close();

                    ret = true;
                }

                OleDbCommand Cmd3 = new OleDbCommand("SELECT * FROM RegistreImportacio", connection);

                OleDbDataReader data3 = Managers.DBManager.Instance.ExecuteReader(connection, Cmd3);

                if (data3 != null)
                {
                    while (data3.Read())
                    {
                        f.nom             = data3.GetString(0);
                        f.data_importacio = data3.GetDateTime(1);
                    }

                    data3.Close();
                }

                Managers.DBManager.Instance.CloseConexion(connection);
            }
            return(ret);
        }