projects/stargazer/tariffs_impl.cpp

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Date: 07.11.2007
  19  */
  20
  21 /*
  22  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  23  */
  24
  25 /*
  26  $Revision: 1.9 $
  27  $Date: 2010/10/07 18:43:21 $
  28  $Author: faust $
  29  */
  30
  31 #include "tariffs_impl.h"
  32
  33 #include "stg/logger.h"
  34 #include "stg/store.h"
  35 #include "stg/admin.h"
  36 #include "stg/admin_conf.h"
  37
  38 #include <cassert>
  39 #include <algorithm>
  40
  41 using STG::TariffsImpl;
  42
  43 //-----------------------------------------------------------------------------
  44 TariffsImpl::TariffsImpl(Store * st)
  45     : store(st),
  46       WriteServLog(Logger::get()),
  47       noTariff(NO_TARIFF_NAME)
  48 {
  49 }
  50 //-----------------------------------------------------------------------------
  51 int TariffsImpl::ReadTariffs()
  52 {
  53 std::lock_guard<std::mutex> lock(m_mutex);
  54
  55 std::vector<std::string> tariffsList;
  56 if (store->GetTariffsList(&tariffsList))
  57     {
  58     WriteServLog("Cannot get tariffs list.");
  59     WriteServLog("%s", store->GetStrError().c_str());
  60     }
  61
  62 Data::size_type tariffsNum = tariffsList.size();
  63
  64 for (Data::size_type i = 0; i < tariffsNum; i++)
  65     {
  66     TariffData td;
  67     if (store->RestoreTariff(&td, tariffsList[i]))
  68         {
  69         WriteServLog("Cannot read tariff %s.", tariffsList[i].c_str());
  70         WriteServLog("%s", store->GetStrError().c_str());
  71         return -1;
  72         }
  73     tariffs.push_back(TariffImpl(td));
  74     }
  75
  76 return 0;
  77 }
  78 //-----------------------------------------------------------------------------
  79 size_t TariffsImpl::Count() const
  80 {
  81 std::lock_guard<std::mutex> lock(m_mutex);
  82 return tariffs.size();
  83 }
  84 //-----------------------------------------------------------------------------
  85 const STG::Tariff* TariffsImpl::FindByName(const std::string & name) const
  86 {
  87 if (name == NO_TARIFF_NAME)
  88     return &noTariff;
  89
  90 std::lock_guard<std::mutex> lock(m_mutex);
  91 const auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(name));
  92
  93 if (ti != tariffs.end())
  94     return &(*ti);
  95
  96 return NULL;
  97 }
  98 //-----------------------------------------------------------------------------
  99 int TariffsImpl::Chg(const TariffData & td, const Admin * admin)
 100 {
 101 const auto& priv = admin->priv();
 102
 103 if (!priv.tariffChg)
 104     {
 105     std::string s = admin->logStr() + " Change tariff \'"
 106                + td.tariffConf.name + "\'. Access denied.";
 107     strError = "Access denied.";
 108     WriteServLog(s.c_str());
 109     return -1;
 110     }
 111
 112 std::lock_guard<std::mutex> lock(m_mutex);
 113
 114 auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(td.tariffConf.name));
 115
 116 if (ti == tariffs.end())
 117     {
 118     strError = "Tariff \'" + td.tariffConf.name + "\' cannot be changed. Tariff does not exist.";
 119     WriteServLog("%s %s", admin->logStr().c_str(), strError.c_str());
 120     return -1;
 121     }
 122
 123 *ti = td;
 124
 125 if (store->SaveTariff(td, td.tariffConf.name))
 126     {
 127     std::string error = "Tariff " + td.tariffConf.name + " writing error. " + store->GetStrError();
 128     WriteServLog(error.c_str());
 129     return -1;
 130     }
 131
 132 WriteServLog("%s Tariff \'%s\' changed.",
 133              admin->logStr().c_str(), td.tariffConf.name.c_str());
 134
 135 return 0;
 136 }
 137 //-----------------------------------------------------------------------------
 138 int TariffsImpl::Del(const std::string & name, const Admin * admin)
 139 {
 140 const auto& priv = admin->priv();
 141
 142 if (!priv.tariffChg)
 143     {
 144     std::string s = admin->logStr() + " Delete tariff \'"
 145                + name + "\'. Access denied.";
 146     strError = "Access denied.";
 147     WriteServLog(s.c_str());
 148     return -1;
 149     }
 150
 151 TariffData td;
 152
 153     {
 154     std::lock_guard<std::mutex> lock(m_mutex);
 155
 156     const auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(name));
 157
 158     if (ti == tariffs.end())
 159         {
 160         strError = "Tariff \'" + name + "\' cannot be deleted. Tariff does not exist.";
 161         WriteServLog("%s %s", admin->logStr().c_str(), strError.c_str());
 162         return -1;
 163         }
 164
 165     if (store->DelTariff(name))
 166         {
 167         WriteServLog("Cannot delete tariff %s.", name.c_str());
 168         WriteServLog("%s", store->GetStrError().c_str());
 169         return -1;
 170         }
 171
 172     td = ti->GetTariffData();
 173
 174     tariffs.erase(ti);
 175     }
 176
 177 m_onDelCallbacks.notify(td);
 178
 179 WriteServLog("%s Tariff \'%s\' deleted.",
 180              admin->logStr().c_str(),
 181              name.c_str());
 182 return 0;
 183 }
 184 //-----------------------------------------------------------------------------
 185 int TariffsImpl::Add(const std::string & name, const Admin * admin)
 186 {
 187 const auto& priv = admin->priv();
 188
 189 if (!priv.tariffChg)
 190     {
 191     std::string s = admin->logStr() + " Add tariff \'"
 192                + name + "\'. Access denied.";
 193     strError = "Access denied.";
 194     WriteServLog(s.c_str());
 195     return -1;
 196     }
 197
 198     {
 199     std::lock_guard<std::mutex> lock(m_mutex);
 200
 201     const auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(name));
 202
 203     if (ti != tariffs.end())
 204         {
 205         strError = "Tariff \'" + name + "\' cannot be added. Tariff already exist.";
 206         WriteServLog("%s %s", admin->logStr().c_str(), strError.c_str());
 207         return -1;
 208         }
 209
 210     tariffs.push_back(TariffImpl(name));
 211     }
 212
 213 if (store->AddTariff(name) < 0)
 214     {
 215     strError = "Tariff " + name + " adding error. " + store->GetStrError();
 216     WriteServLog(strError.c_str());
 217     return -1;
 218     }
 219
 220 m_onAddCallbacks.notify(tariffs.back().GetTariffData());
 221
 222 WriteServLog("%s Tariff \'%s\' added.",
 223                  admin->logStr().c_str(), name.c_str());
 224
 225 return 0;
 226 }
 227 //-----------------------------------------------------------------------------
 228 void TariffsImpl::GetTariffsData(std::vector<TariffData> * tdl) const
 229 {
 230 assert(tdl != NULL && "Tariffs data list is not null");
 231 std::lock_guard<std::mutex> lock(m_mutex);
 232
 233 auto it = tariffs.begin();
 234 for (; it != tariffs.end(); ++it)
 235     {
 236     tdl->push_back(it->GetTariffData());
 237     }
 238 }
 239 //-----------------------------------------------------------------------------