Changeset 16eed2b in observatorio


Ignore:
Timestamp:
Jan 13, 2015, 8:10:35 AM (9 years ago)
Author:
Alejandro <amujica@…>
Branches:
simulacion
Children:
23f4971
Parents:
23daf5e
Message:

Corregida la repeticion de arcos y las cantidades no asignadas. Agregada ubicacion de la empresa

Location:
simulacion/ModuloDinamico
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • simulacion/ModuloDinamico/good.C

    r6217e66 r16eed2b  
    2828
    2929Good::Good()
    30   : company_rif(), company_name(), nationality("N"), id(0), name(),
    31     tariff_code(), measurement_unit(), level(0)
     30  : company_rif(), company_name(), company_location(), nationality("N"), id(0),
     31    name(), tariff_code(), measurement_unit(), level(0)
    3232{
    3333  // Empty
    … …  
    3636Good::Good(const Good & good)
    3737  : company_rif(good.company_rif), company_name(good.company_name),
    38     nationality(good.nationality), id(good.id), name(good.name),
    39     tariff_code(good.tariff_code), measurement_unit(good.measurement_unit),
    40     level(good.level)
     38    company_location(good.company_location), nationality(good.nationality),
     39    id(good.id), name(good.name), tariff_code(good.tariff_code),
     40    measurement_unit(good.measurement_unit), level(good.level)
    4141{
    4242  // Empty
    … …  
    4444
    4545Good::Good(Good && good)
    46   : company_rif(), company_name(), nationality("N"), id(0), name(),
    47     tariff_code(), measurement_unit(), level(0)
     46  : company_rif(), company_name(), company_location(), nationality("N"), id(0),
     47    name(), tariff_code(), measurement_unit(), level(0)
     48{
     49  std::swap(company_rif, good.company_rif);
     50  std::swap(company_name, good.company_name);
     51  std::swap(company_location, good.company_location);
     52  std::swap(nationality, good.nationality);
     53  std::swap(id, good.id);
     54  std::swap(name, good.name);
     55  std::swap(tariff_code, good.tariff_code);
     56  std::swap(measurement_unit, good.measurement_unit);
     57  std::swap(level, good.level);
     58}
     59
     60const std::string & Good::get_company_rif() const
     61{
     62  return company_rif;
     63}
     64
     65void Good::set_company_rif(const std::string & _company_rif)
     66{
     67  company_rif = _company_rif;
     68}
     69
     70void Good::set_company_rif(std::string && _company_rif)
     71{
     72  company_rif = std::move(_company_rif);
     73}
     74
     75const std::string & Good::get_company_name() const
     76{
     77  return company_name;
     78}
     79
     80void Good::set_company_name(const std::string & _company_name)
     81{
     82  company_name = _company_name;
     83}
     84
     85void Good::set_company_name(std::string && _company_name)
     86{
     87  company_name = std::move(_company_name);
     88}
     89
     90const std::string & Good::get_company_location() const
     91{
     92  return company_location;
     93}
     94
     95void Good::set_company_location(const std::string & _company_location)
     96{
     97  company_location = _company_location;
     98}
     99
     100void Good::set_company_location(std::string && _company_location)
     101{
     102  company_location = std::move(_company_location);
     103}
     104
     105const std::string & Good::get_nationality() const
     106{
     107  return nationality;
     108}
     109
     110void Good::set_nationality(const std::string & _nationality)
     111{
     112  nationality = _nationality;
     113}
     114
     115void Good::set_nationality(std::string && _nationality)
     116{
     117  nationality = std::move(_nationality);
     118}
     119
     120
     121const db_id_t & Good::get_id() const
     122{
     123  return id;
     124}
     125
     126void Good::set_id(const db_id_t & _id)
     127{
     128  id = _id;
     129}
     130
     131const std::string & Good::get_name() const
     132{
     133  return name;
     134}
     135
     136void Good::set_name(const std::string & _name)
     137{
     138  name = _name;
     139}
     140
     141void Good::set_name(std::string && _name)
     142{
     143  name = std::move(_name);
     144}
     145
     146const std::string & Good::get_tariff_code() const
     147{
     148  return tariff_code;
     149}
     150
     151void Good::set_tariff_code(const std::string & _tariff_code)
     152{
     153  tariff_code = _tariff_code;
     154}
     155
     156void Good::set_tariff_code(std::string && _tariff_code)
     157{
     158  tariff_code = std::move(_tariff_code);
     159}
     160
     161const std::string & Good::get_measurement_unit() const
     162{
     163  return measurement_unit;
     164}
     165
     166void Good::set_measurement_unit(const std::string & _measurement_unit)
     167{
     168  measurement_unit = _measurement_unit;
     169}
     170
     171void Good::set_measurement_unit(std::string && _measurement_unit)
     172{
     173  measurement_unit = std::move(_measurement_unit);
     174}
     175
     176const int & Good::get_level() const
     177{
     178  return level;
     179}
     180
     181void Good::set_level(const int & _level)
     182{
     183  level = _level;
     184}
     185
     186Good & Good::operator = (const Good & good)
     187{
     188  if (&good == this)
     189    return *this;
     190
     191  company_rif = good.company_rif;
     192  company_name = good.company_name;
     193  nationality = good.nationality;
     194  id = good.id;
     195  name = good.name;
     196  tariff_code = good.tariff_code;
     197  measurement_unit = good.measurement_unit;
     198  level = good.level;
     199
     200  return *this;
     201}
     202
     203Good & Good::operator = (Good && good)
    48204{
    49205  std::swap(company_rif, good.company_rif);
    … …  
    55211  std::swap(measurement_unit, good.measurement_unit);
    56212  std::swap(level, good.level);
    57 }
    58 
    59 const std::string & Good::get_company_rif() const
    60 {
    61   return company_rif;
    62 }
    63 
    64 void Good::set_company_rif(const std::string & _company_rif)
    65 {
    66   company_rif = _company_rif;
    67 }
    68 
    69 void Good::set_company_rif(std::string && _company_rif)
    70 {
    71   company_rif = std::move(_company_rif);
    72 }
    73 
    74 const std::string & Good::get_company_name() const
    75 {
    76   return company_name;
    77 }
    78 
    79 void Good::set_company_name(const std::string & _company_name)
    80 {
    81   company_name = _company_name;
    82 }
    83 
    84 void Good::set_company_name(std::string && _company_name)
    85 {
    86   company_name = std::move(_company_name);
    87 }
    88 
    89 const std::string & Good::get_nationality() const
    90 {
    91   return nationality;
    92 }
    93 
    94 void Good::set_nationality(const std::string & _nationality)
    95 {
    96   nationality = _nationality;
    97 }
    98 
    99 void Good::set_nationality(std::string && _nationality)
    100 {
    101   nationality = std::move(_nationality);
    102 }
    103 
    104 
    105 const db_id_t & Good::get_id() const
    106 {
    107   return id;
    108 }
    109 
    110 void Good::set_id(const db_id_t & _id)
    111 {
    112   id = _id;
    113 }
    114 
    115 const std::string & Good::get_name() const
    116 {
    117   return name;
    118 }
    119 
    120 void Good::set_name(const std::string & _name)
    121 {
    122   name = _name;
    123 }
    124 
    125 void Good::set_name(std::string && _name)
    126 {
    127   name = std::move(_name);
    128 }
    129 
    130 const std::string & Good::get_tariff_code() const
    131 {
    132   return tariff_code;
    133 }
    134 
    135 void Good::set_tariff_code(const std::string & _tariff_code)
    136 {
    137   tariff_code = _tariff_code;
    138 }
    139 
    140 void Good::set_tariff_code(std::string && _tariff_code)
    141 {
    142   tariff_code = std::move(_tariff_code);
    143 }
    144 
    145 const std::string & Good::get_measurement_unit() const
    146 {
    147   return measurement_unit;
    148 }
    149 
    150 void Good::set_measurement_unit(const std::string & _measurement_unit)
    151 {
    152   measurement_unit = _measurement_unit;
    153 }
    154 
    155 void Good::set_measurement_unit(std::string && _measurement_unit)
    156 {
    157   measurement_unit = std::move(_measurement_unit);
    158 }
    159 
    160 const int & Good::get_level() const
    161 {
    162   return level;
    163 }
    164 
    165 void Good::set_level(const int & _level)
    166 {
    167   level = _level;
    168 }
    169 
    170 Good & Good::operator = (const Good & good)
    171 {
    172   if (&good == this)
    173     return *this;
    174 
    175   company_rif = good.company_rif;
    176   company_name = good.company_name;
    177   nationality = good.nationality;
    178   id = good.id;
    179   name = good.name;
    180   tariff_code = good.tariff_code;
    181   measurement_unit = good.measurement_unit;
    182   level = good.level;
    183 
    184   return *this;
    185 }
    186 
    187 Good & Good::operator = (Good && good)
    188 {
    189   std::swap(company_rif, good.company_rif);
    190   std::swap(company_name, good.company_name);
    191   std::swap(nationality, good.nationality);
    192   std::swap(id, good.id);
    193   std::swap(name, good.name);
    194   std::swap(tariff_code, good.tariff_code);
    195   std::swap(measurement_unit, good.measurement_unit);
    196   std::swap(level, good.level);
    197213
    198214  return *this;

  • simulacion/ModuloDinamico/good.H

    r71c519d r16eed2b  
    5555  std::string company_name;
    5656
     57  /// Ubicación
     58  std::string company_location;
     59
    5760  /// Nacionalidad.
    5861  std::string nationality;
    … …  
    8992
    9093  void set_company_name(std::string &&);
     94
     95  const std::string & get_company_location() const;
     96
     97  void set_company_location(const std::string &);
     98
     99  void set_company_location(std::string &&);
    91100
    92101  const std::string & get_nationality() const;

  • simulacion/ModuloDinamico/io_manager.C

    r71c519d r16eed2b  
    155155const std::string IO_Manager::XML_COMPANY_RIF = "company_rif";
    156156
     157const std::string IO_Manager::XML_COMPANY_LOCATION = "company_location";
     158
    157159const std::string IO_Manager::XML_COMPANY_NATIONALITY = "company_nationality";
    158160

  • simulacion/ModuloDinamico/io_manager.H

    r666042a r16eed2b  
    166166  static const std::string XML_COMPANY_RIF;
    167167
     168  static const std::string XML_COMPANY_LOCATION;
     169
    168170  static const std::string XML_COMPANY_NATIONALITY;
    169171
    … …  
    482484                              input.get_company_name()
    483485                            );
     486                            ptr_imported_product->set_company_location(
     487                              input.get_company_location()
     488                            );
    484489                            ptr_imported_product->set_nationality(
    485490                              input.get_nationality()
    … …  
    903908        node->set_attribute(XML_COMPANY_RIF, good->get_company_rif());
    904909        node->set_attribute(XML_COMPANY_NAME, good->get_company_name());
     910        node->set_attribute(XML_COMPANY_LOCATION, good->get_company_location());
    905911        node->set_attribute(XML_COMPANY_NATIONALITY, good->get_nationality());
    906912
    … …  
    11631169                    node->get_attribute_value(XML_COMPANY_NAME).c_str()
    11641170                  );
     1171                  good->set_company_location(
     1172                    node->get_attribute_value(XML_COMPANY_LOCATION).c_str()
     1173                  );
    11651174                  good->set_nationality(
    11661175                    node->get_attribute_value(XML_COMPANY_NATIONALITY)
    … …  
    15601569        node->set_attribute(XML_COMPANY_RIF, good->get_company_rif());
    15611570        node->set_attribute(XML_COMPANY_NAME, good->get_company_name());
     1571        node->set_attribute(XML_COMPANY_LOCATION, good->get_company_location());
    15621572        node->set_attribute(XML_COMPANY_NATIONALITY, good->get_nationality());
    15631573

  • simulacion/ModuloDinamico/queries.C

    r666042a r16eed2b  
    165165  str_query.addSelect(concatas(DB::COMPANY_TABLE_NAME, DB::RIF));
    166166  str_query.addSelect(concatas(DB::COMPANY_TABLE_NAME, DB::COMPANY_NAME));
     167  str_query.addSelect(concatas(DB::STATE_TABLE_NAME, DB::NAME));
    167168
    168169  str_query.addFrom(DB::PRODUCT_TABLE_NAME);
    … …  
    170171  str_query.addFrom(DB::PLANT_TABLE_NAME);
    171172  str_query.addFrom(DB::COMPANY_TABLE_NAME);
     173  str_query.addFrom(DB::STATE_TABLE_NAME);
     174  str_query.addFrom(DB::TOWN_TABLE_NAME);
     175  str_query.addFrom(DB::PARISH_TABLE_NAME);
    172176
    173177  str_query.addWhere(op(concat(DB::PRODUCT_TABLE_NAME, DB::ID),
    … …  
    182186  str_query.addWhere(op(concat(DB::COMPANY_TABLE_NAME, DB::RIF),
    183187                        concat(DB::PLANT_TABLE_NAME, DB::UE_RIF)));
     188  str_query.addWhere(op(concat(DB::COMPANY_TABLE_NAME, DB::PARISH_CODE),
     189                        concat(DB::PARISH_TABLE_NAME, DB::CODE)));
     190  str_query.addWhere(op(concat(DB::PARISH_TABLE_NAME, DB::TOWN_CODE),
     191                        concat(DB::TOWN_TABLE_NAME, DB::CODE)));
     192  str_query.addWhere(op(concat(DB::TOWN_TABLE_NAME, DB::STATE_CODE),
     193                        concat(DB::STATE_TABLE_NAME, DB::CODE)));
    184194
    185195  if (not query.exec(str_query))
    … …  
    198208  product.set_company_rif(
    199209    query.getValue(concat(DB::COMPANY_TABLE_NAME, DB::RIF, '_')));
     210  product.set_company_location(
     211    query.getValue(concat(DB::STATE_TABLE_NAME, DB::NAME, '_')));
    200212  product.set_id(
    201213    std::atol(query.getValue(concat(DB::PRODUCT_TABLE_NAME, DB::ID, '_'))));
    … …  
    233245}
    234246
     247std::string get_supplier_name(const std::string & rif)
     248{
     249  AutoConnection conn;
     250
     251  DBQuery query(conn);
     252
     253  StrQuery str_query;
     254
     255  str_query.addSelect(DB::NAME);
     256  str_query.addFrom(DB::SUPPLIER_TABLE_NAME);
     257  str_query.addWhere(op(DB::RIF, single_quote(rif)));
     258
     259  if (not query.exec(str_query))
     260    {
     261      std::string msg = "Cannot execute query: " + std::string(str_query);
     262
     263      throw std::logic_error(msg);
     264    }
     265
     266  if (not query.next())
     267    {
     268      std::stringstream msg;
     269
     270      msg << "Supplier with R.I.F. = " << rif
     271          << " does not exists in database";
     272
     273      throw std::domain_error(msg.str());
     274    }
     275
     276  return query.getValue(0);
     277}
     278
    235279void list_inputs(const db_id_t & input_id, const std::string & year,
    236280                 List<Input> & inputs)
    … …  
    280324  query.clear();
    281325
    282   str_query.addSelect(concatas(DB::SUPPLIER_TABLE_NAME, DB::NAME));
    283   str_query.addSelect(concatas(DB::SUPPLIER_TABLE_NAME, DB::RIF));
    284   str_query.addSelect(concatas(DB::SUPPLIER_TABLE_NAME, DB::NATIONALITY));
    285 
    286   str_query.addFrom(DB::INPUT_SUPPLIER_TABLE_NAME);
    287   str_query.addFrom(DB::SUPPLIER_TABLE_NAME);
    288      
    289   str_query.addWhere(op(concat(DB::INPUT_SUPPLIER_TABLE_NAME, DB::YEAR_R),
    290                         year));
    291   str_query.addWhere(op(concat(DB::INPUT_SUPPLIER_TABLE_NAME, DB::INPUT_ID),
    292                         id_to_str(input_id)));
    293   str_query.addWhere(op(concat(DB::INPUT_SUPPLIER_TABLE_NAME,
    294                                DB::SUPPLIER_ID),
    295                         concat(DB::SUPPLIER_TABLE_NAME, DB::ID)));
    296 
    297   if (not query.exec(str_query))
    298     {
    299       std::string msg = "Cannot execute query: " + std::string(str_query);
     326  std::string strquery =
     327    "SELECT " +
     328    concatas(DB::SUPPLIER_TABLE_NAME, DB::RIF) + ',' +
     329    concatas(DB::SUPPLIER_TABLE_NAME, DB::NATIONALITY) + ',' +
     330    concatas(DB::COUNTRY_TABLE_NAME, DB::NAME) +
     331    " FROM " +
     332    DB::INPUT_SUPPLIER_TABLE_NAME + ',' +
     333    DB::SUPPLIER_TABLE_NAME + ',' +
     334    DB::COUNTRY_TABLE_NAME +
     335    " WHERE " +
     336    op(concat(DB::INPUT_SUPPLIER_TABLE_NAME, DB::YEAR_R), year) + " AND " +
     337    op(concat(DB::INPUT_SUPPLIER_TABLE_NAME, DB::INPUT_ID),
     338                       id_to_str(input_id)) + " AND " +
     339    op(concat(DB::INPUT_SUPPLIER_TABLE_NAME, DB::SUPPLIER_ID),
     340       concat(DB::SUPPLIER_TABLE_NAME, DB::ID)) + " AND " +
     341    op(concat(DB::COUNTRY_TABLE_NAME, DB::ID),
     342       concat(DB::SUPPLIER_TABLE_NAME, DB::ORIG_COUNTRY_ID)) +
     343    " GROUP BY " +
     344    concat(DB::SUPPLIER_TABLE_NAME, DB::RIF, '_') + ',' +
     345    concat(DB::SUPPLIER_TABLE_NAME, DB::NATIONALITY, '_') + ',' +
     346    concat(DB::COUNTRY_TABLE_NAME, DB::NAME, '_');
     347
     348
     349  if (not query.exec(strquery))
     350    {
     351      std::string msg = "Cannot execute query: " + std::string(strquery);
    300352      throw std::logic_error(msg);
    301353    }
    … …  
    304356    {
    305357      input.set_company_rif(
    306         query.getValue(concat(DB::SUPPLIER_TABLE_NAME, DB::RIF, '_')));
    307       input.set_company_name(
    308         query.getValue(concat(DB::SUPPLIER_TABLE_NAME, DB::NAME, '_')));
     358        query.getValue(concat(DB::SUPPLIER_TABLE_NAME, DB::RIF, '_'))
     359      );
     360      input.set_company_name(get_supplier_name(input.get_company_rif()));
     361      input.set_company_location(
     362        query.getValue(concat(DB::COUNTRY_TABLE_NAME, DB::NAME, '_'))
     363      );
    309364      input.set_nationality(query.getValue(concat(DB::SUPPLIER_TABLE_NAME,
    310365                                                  DB::NATIONALITY, '_')));
    … …  
    412467  DBQuery query(conn);
    413468
    414   StrQuery str_query;
    415 
    416   str_query.addSelect(concatas(DB::INPUT_SUPPLIER_TABLE_NAME,
    417                                DB::BOUGHT_QUANTITY));
    418 
    419   str_query.addFrom(DB::INPUT_SUPPLIER_TABLE_NAME);
    420   str_query.addFrom(DB::SUPPLIER_TABLE_NAME);
    421 
    422   str_query.addWhere(op(concat(DB::INPUT_SUPPLIER_TABLE_NAME, DB::YEAR_R),
    423                         year));
     469  std::string sum = "SUM(" + concat(DB::INPUT_SUPPLIER_TABLE_NAME,
     470                                    DB::BOUGHT_QUANTITY) + ")";
     471
     472  std::string str_query = "SELECT " + sum
     473                        + " FROM " + DB::INPUT_SUPPLIER_TABLE_NAME + ", "
     474                                   + DB::SUPPLIER_TABLE_NAME +
     475                        + " WHERE " +
     476                        op(concat(DB::INPUT_SUPPLIER_TABLE_NAME, DB::YEAR_R),
     477                           year) + " AND " +
     478                        op(concat(DB::SUPPLIER_TABLE_NAME, DB::ID),
     479                           concat(DB::INPUT_SUPPLIER_TABLE_NAME,
     480                                  DB::SUPPLIER_ID)) + " AND " +
     481                        op(concat(DB::INPUT_SUPPLIER_TABLE_NAME, DB::INPUT_ID),
     482                                  id_to_str(input_id)) + " AND ";
     483
     484  std::string group = " GROUP BY ";
     485
    424486  if (rif.size() > 0)
    425     str_query.addWhere(op(concat(DB::SUPPLIER_TABLE_NAME, DB::RIF),
     487    {
     488      str_query.append(op(concat(DB::SUPPLIER_TABLE_NAME, DB::RIF),
    426489                          single_quote(rif)));
     490      group.append(concat(DB::SUPPLIER_TABLE_NAME, DB::RIF));
     491    }
    427492  else
    428     str_query.addWhere(op(concat(DB::SUPPLIER_TABLE_NAME, DB::NAME),
     493    {
     494      str_query.append(op(concat(DB::SUPPLIER_TABLE_NAME, DB::NAME),
    429495                          single_quote(company_name)));
    430 
    431   str_query.addWhere(op(concat(DB::SUPPLIER_TABLE_NAME, DB::ID),
    432                         concat(DB::INPUT_SUPPLIER_TABLE_NAME,
    433                               DB::SUPPLIER_ID)));
    434   str_query.addWhere(op(concat(DB::INPUT_SUPPLIER_TABLE_NAME, DB::INPUT_ID),
    435                         id_to_str(input_id)));
    436 
    437   if (not query.exec(str_query))
    438     {
    439       std::string msg = "Cannot execute query: " + std::string(str_query);
     496      group.append(concat(DB::SUPPLIER_TABLE_NAME, DB::NAME));
     497    }
     498
     499  str_query.append(group);
     500
     501  if (not query.exec(str_query))
     502    {
     503      std::string msg = "Cannot execute query: " + str_query;
    440504      throw std::logic_error(msg);
    441505    }
Note: See TracChangeset for help on using the changeset viewer.