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/locker.h"
  34 #include "stg/logger.h"
  35 #include "stg/store.h"
  36 #include "stg/admin.h"
  37 #include "stg/admin_conf.h"
  38
  39 #include <cassert>
  40 #include <algorithm>
  41
  42 using STG::TariffsImpl;
  43
  44 //-----------------------------------------------------------------------------
  45 TariffsImpl::TariffsImpl(Store * st)
  46     : store(st),
  47       WriteServLog(Logger::get()),
  48       noTariff(NO_TARIFF_NAME)
  49 {
  50 }
  51 //-----------------------------------------------------------------------------
  52 int TariffsImpl::ReadTariffs()
  53 {
  54 std::lock_guard<std::mutex> lock(m_mutex);
  55
  56 std::vector<std::string> tariffsList;
  57 if (store->GetTariffsList(&tariffsList))
  58     {
  59     WriteServLog("Cannot get tariffs list.");
  60     WriteServLog("%s", store->GetStrError().c_str());
  61     }
  62
  63 Data::size_type tariffsNum = tariffsList.size();
  64
  65 for (Data::size_type i = 0; i < tariffsNum; i++)
  66     {
  67     TariffData td;
  68     if (store->RestoreTariff(&td, tariffsList[i]))
  69         {
  70         WriteServLog("Cannot read tariff %s.", tariffsList[i].c_str());
  71         WriteServLog("%s", store->GetStrError().c_str());
  72         return -1;
  73         }
  74     tariffs.push_back(TariffImpl(td));
  75     }
  76
  77 return 0;
  78 }
  79 //-----------------------------------------------------------------------------
  80 size_t TariffsImpl::Count() const
  81 {
  82 std::lock_guard<std::mutex> lock(m_mutex);
  83 return tariffs.size();
  84 }
  85 //-----------------------------------------------------------------------------
  86 const STG::Tariff* TariffsImpl::FindByName(const std::string & name) const
  87 {
  88 if (name == NO_TARIFF_NAME)
  89     return &noTariff;
  90
  91 std::lock_guard<std::mutex> lock(m_mutex);
  92 const auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(name));
  93
  94 if (ti != tariffs.end())
  95     return &(*ti);
  96
  97 return NULL;
  98 }
  99 //-----------------------------------------------------------------------------
 100 int TariffsImpl::Chg(const TariffData & td, const Admin * admin)
 101 {
 102 const auto& priv = admin->priv();
 103
 104 if (!priv.tariffChg)
 105     {
 106     std::string s = admin->logStr() + " Change tariff \'"
 107                + td.tariffConf.name + "\'. Access denied.";
 108     strError = "Access denied.";
 109     WriteServLog(s.c_str());
 110     return -1;
 111     }
 112
 113 std::lock_guard<std::mutex> lock(m_mutex);
 114
 115 auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(td.tariffConf.name));
 116
 117 if (ti == tariffs.end())
 118     {
 119     strError = "Tariff \'" + td.tariffConf.name + "\' cannot be changed. Tariff does not exist.";
 120     WriteServLog("%s %s", admin->logStr().c_str(), strError.c_str());
 121     return -1;
 122     }
 123
 124 *ti = td;
 125
 126 if (store->SaveTariff(td, td.tariffConf.name))
 127     {
 128     std::string error = "Tariff " + td.tariffConf.name + " writing error. " + store->GetStrError();
 129     WriteServLog(error.c_str());
 130     return -1;
 131     }
 132
 133 WriteServLog("%s Tariff \'%s\' changed.",
 134              admin->logStr().c_str(), td.tariffConf.name.c_str());
 135
 136 return 0;
 137 }
 138 //-----------------------------------------------------------------------------
 139 int TariffsImpl::Del(const std::string & name, const Admin * admin)
 140 {
 141 const auto& priv = admin->priv();
 142
 143 if (!priv.tariffChg)
 144     {
 145     std::string s = admin->logStr() + " Delete tariff \'"
 146                + name + "\'. Access denied.";
 147     strError = "Access denied.";
 148     WriteServLog(s.c_str());
 149     return -1;
 150     }
 151
 152 TariffData td;
 153
 154     {
 155     std::lock_guard<std::mutex> lock(m_mutex);
 156
 157     const auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(name));
 158
 159     if (ti == tariffs.end())
 160         {
 161         strError = "Tariff \'" + name + "\' cannot be deleted. Tariff does not exist.";
 162         WriteServLog("%s %s", admin->logStr().c_str(), strError.c_str());
 163         return -1;
 164         }
 165
 166     if (store->DelTariff(name))
 167         {
 168         WriteServLog("Cannot delete tariff %s.", name.c_str());
 169         WriteServLog("%s", store->GetStrError().c_str());
 170         return -1;
 171         }
 172
 173     td = ti->GetTariffData();
 174
 175     tariffs.erase(ti);
 176     }
 177
 178 m_onDelCallbacks.notify(td);
 179
 180 WriteServLog("%s Tariff \'%s\' deleted.",
 181              admin->logStr().c_str(),
 182              name.c_str());
 183 return 0;
 184 }
 185 //-----------------------------------------------------------------------------
 186 int TariffsImpl::Add(const std::string & name, const Admin * admin)
 187 {
 188 const auto& priv = admin->priv();
 189
 190 if (!priv.tariffChg)
 191     {
 192     std::string s = admin->logStr() + " Add tariff \'"
 193                + name + "\'. Access denied.";
 194     strError = "Access denied.";
 195     WriteServLog(s.c_str());
 196     return -1;
 197     }
 198
 199     {
 200     std::lock_guard<std::mutex> lock(m_mutex);
 201
 202     const auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(name));
 203
 204     if (ti != tariffs.end())
 205         {
 206         strError = "Tariff \'" + name + "\' cannot be added. Tariff already exist.";
 207         WriteServLog("%s %s", admin->logStr().c_str(), strError.c_str());
 208         return -1;
 209         }
 210
 211     tariffs.push_back(TariffImpl(name));
 212     }
 213
 214 if (store->AddTariff(name) < 0)
 215     {
 216     strError = "Tariff " + name + " adding error. " + store->GetStrError();
 217     WriteServLog(strError.c_str());
 218     return -1;
 219     }
 220
 221 m_onAddCallbacks.notify(tariffs.back().GetTariffData());
 222
 223 WriteServLog("%s Tariff \'%s\' added.",
 224                  admin->logStr().c_str(), name.c_str());
 225
 226 return 0;
 227 }
 228 //-----------------------------------------------------------------------------
 229 void TariffsImpl::GetTariffsData(std::vector<TariffData> * tdl) const
 230 {
 231 assert(tdl != NULL && "Tariffs data list is not null");
 232 std::lock_guard<std::mutex> lock(m_mutex);
 233
 234 auto it = tariffs.begin();
 235 for (; it != tariffs.end(); ++it)
 236     {
 237     tdl->push_back(it->GetTariffData());
 238     }
 239 }
 240 //-----------------------------------------------------------------------------