HK_Batch.cpp

Go to the documentation of this file.

/******************************************************************/
#include "../headers/Batch.h"
 
HK_Batch::HK_Batch(){}
 
HK_Batch::HK_Batch(int ID, string Name, string Type,
    string Breed, string Group, string Comments,string Incubator,
    int Eggs, int Fertile, int Chicks,
    HK_Date Start, HK_Date Candle, HK_Date Lockdown, HK_Date Hatch,
    int Remind, int Adv ){
        
    Set( ID, Name, Type, Breed, Group, Comments, Incubator, Eggs, 
        Fertile, Chicks, Start, Candle, Lockdown, Hatch, Remind, Adv);
}
 
HK_Batch::~HK_Batch(){}
 
HK_KeyValue HK_Batch::Search(string Value, bool SearchBatch, bool SearchAdv)
{
    HK_KeyValue Results;
 
    if(SearchBatch) {
        string Name = HK_BatchName;
        string Breed = HK_BatchBreed;
        string Type = HK_BatchType;
        string Group = HK_BatchGroup;
        string Incubator = HK_BatchIncubator;
        string Comments = HK_BatchComments;
        
        transform(Value.begin(),Value.end(),Value.begin(), ::tolower);
        transform(Name.begin(),Name.end(),Name.begin(), ::tolower);
        transform(Breed.begin(),Breed.end(),Breed.begin(), ::tolower);
        transform(Type.begin(),Type.end(),Type.begin(), ::tolower);
        transform(Group.begin(),Group.end(),Group.begin(), ::tolower);
        transform(Incubator.begin(),Incubator.end(),Incubator.begin(), ::tolower);
        transform(Comments.begin(),Comments.end(),Comments.begin(), ::tolower);
 
        if(Name.find(Value) != string::npos)
            Results.Add("Batch " + HK_BatchName + "'s Name", HK_BatchName);
 
        if(Breed.find(Value) != string::npos)
            Results.Add("Batch " + HK_BatchName + "'s Breed", HK_BatchBreed);
 
        if(Type.find(Value) != string::npos)
            Results.Add("Batch " + HK_BatchName + "'s Type", HK_BatchType);
 
        if(Group.find(Value) != string::npos)
            Results.Add("Batch " + HK_BatchName + "'s Group", HK_BatchGroup);
 
        if(Incubator.find(Value) != string::npos)
            Results.Add("Batch " + HK_BatchName + "'s Incubator", HK_BatchIncubator);
 
        if(Comments.find(Value) != string::npos)
            Results.Add("Batch " + HK_BatchName + "'s Comments", HK_BatchComments);
    }
    
    if(SearchAdv)
        Results.Add(HK_BatchAdvanced.Search(Value,HK_BatchName));
    
    return Results;
    
}
 
void HK_Batch::Set(int ID, string Name, string Type,
    string Breed, string Group, string Comments, string Incubator,
    int Eggs, int Fertile, int Chicks,
    HK_Date Start, HK_Date Candle, HK_Date Lockdown, HK_Date Hatch,
    int Remind, int Adv
){
    HK_BatchID = ID;
    HK_BatchName = Name;
    HK_BatchType = Type;
    HK_BatchBreed = Breed;
    HK_BatchGroup = Group;
    HK_BatchComments = Comments;
    HK_BatchIncubator = Incubator;                 
    HK_BatchEggs = Eggs;
    HK_BatchFertile = Fertile;
    HK_BatchChicks = Chicks;             
    HK_BatchStart = Start;
    HK_BatchCandle = Candle;
    HK_BatchLockdown = Lockdown;
    HK_BatchHatch = Hatch;                
    HK_BatchRemind = Remind;
    HK_BatchAdv = Adv;
}
 
void HK_Batch::SetID(int ID){HK_BatchID = ID;}
void HK_Batch::SetName(string Name){HK_BatchName = Name;}
void HK_Batch::SetType(string Type){HK_BatchType = Type;}
void HK_Batch::SetBreed(string Breed){HK_BatchBreed = Breed;}
void HK_Batch::SetGroup(string Group){HK_BatchGroup = Group;}
void HK_Batch::SetComments(string Comments){HK_BatchComments = Comments;}
void HK_Batch::SetIncubator(string Incubator){HK_BatchIncubator = Incubator;}
void HK_Batch::SetEggs(int Eggs){HK_BatchEggs =  Eggs;}
void HK_Batch::SetFertile(int Fertile){HK_BatchFertile = Fertile;}
void HK_Batch::SetChicks(int Chicks){HK_BatchChicks = Chicks;}
void HK_Batch::SetStart(HK_Date Start){HK_BatchStart = Start;}
void HK_Batch::SetCandle(HK_Date Candle){HK_BatchCandle = Candle;}
void HK_Batch::SetLockdown(HK_Date Lockdown){HK_BatchLockdown = Lockdown;}
void HK_Batch::SetHatch(HK_Date Hatch){HK_BatchHatch = Hatch;}
void HK_Batch::SetRemind(int Remind){HK_BatchRemind = Remind;}
void HK_Batch::SetAdv(int Adv){HK_BatchAdv = Adv;}
void HK_Batch::SetAdvanced(HK_Advanced Adv){HK_BatchAdvanced = Adv;}
void HK_Batch::SetAdvEgg(HK_Egg Egg, int Select){HK_BatchAdvanced.SetEgg(Egg,Select);}
void HK_Batch::SetAdvUpdate(bool Status){HK_BatchAdvanced.SetUpdate(Status);}
 
 
int HK_Batch::GetID(){return HK_BatchID;}
string HK_Batch::GetName(){return HK_BatchName;}
string HK_Batch::GetType(){return HK_BatchType ;}
string HK_Batch::GetBreed(){return HK_BatchBreed;}
string HK_Batch::GetGroup(){return HK_BatchGroup ;}
string HK_Batch::GetComments(){return HK_BatchComments;}
string HK_Batch::GetIncubator(){return HK_BatchIncubator;}
int HK_Batch::GetEggs(){return HK_BatchEggs;}
 
int HK_Batch::GetFertile()
{
    if(GetAdv() == 0)
        return HK_BatchFertile;
    else
        return HK_BatchAdvanced.GetFertile();
}
 
int HK_Batch::GetChicks()
{
    if(GetAdv() == 0)
        return HK_BatchChicks;
    else
        return HK_BatchAdvanced.GetChicks();
}
 
HK_Date HK_Batch::GetStart(){return HK_BatchStart;}
HK_Date HK_Batch::GetCandle(){return HK_BatchCandle;}
HK_Date HK_Batch::GetLockdown(){return HK_BatchLockdown;}
HK_Date HK_Batch::GetHatch(){return HK_BatchHatch;}
int HK_Batch::GetRemind(){return HK_BatchRemind;}
int HK_Batch::GetAdv(){return HK_BatchAdv;}
HK_Advanced HK_Batch::GetAdvanced(){return HK_BatchAdvanced;}
 
vector<string> HK_Batch::GetSQL(){return GetSQL(HK_BatchID);}
 
vector<string> HK_Batch::GetSQL(int ID)
{
    vector<string> SQL;
    SQL.push_back("INSERT INTO Batches VALUES(" + to_string(ID) + ", '" + \
    HK_BatchName + "'," + to_string(HK_BatchEggs) + ", '" + HK_BatchType + \
    "', '" + GetStart().ToSortable("/") + "','" + GetCandle().ToSortable("/") + \
    "','" + GetLockdown().ToSortable("/") + "','" + GetHatch().ToSortable("/") + \
    "'," + to_string(HK_BatchFertile) + "," + to_string(HK_BatchChicks) + \
    ",'" + HK_BatchComments + "','" + HK_BatchBreed + "','" + \
    HK_BatchGroup + "','" + HK_BatchIncubator + "'," + \
    to_string(HK_BatchRemind) + "," + to_string(HK_BatchAdv) + ");");
    
    if(GetAdv() == 1)
        SQL.push_back(GetAdvanced().GetSQL());
    return SQL;
}
vector<string> HK_Batch::GetUpdate()
{
    vector<string> Result;
    
    if(HK_BatchAdv == 1)
        Result = HK_BatchAdvanced.GetUpdate();
        
    string SQL = "UPDATE Batches SET ";
    SQL += "BatchName = '" + HK_BatchName + "',";
    SQL += "BatchType = '" + HK_BatchType + "',";
    SQL += "BatchBreed = '" + HK_BatchBreed + "',";
    SQL += "BatchGroup = '" + HK_BatchGroup + "',";
    SQL += "Incubator = '" + HK_BatchIncubator + "',";
    SQL += "BatchComments = '" + HK_BatchComments + "',";
    SQL += "BatchSDate = '" + GetStart().ToSortable("/") + "',";
    SQL += "BatchC1Date = '" + GetCandle().ToSortable("/") + "',";
    SQL += "BatchTDate = '" + GetLockdown().ToSortable("/") + "',";
    SQL += "BatchHDate = '" + GetHatch().ToSortable("/") + "',";
    SQL += "BatchEggs = " + to_string(HK_BatchEggs) + ",";
    SQL += "FertileEggs = " + to_string(HK_BatchFertile) + ",";
    SQL += "ChicksHatched = " + to_string(HK_BatchChicks) + ",";
    SQL += "IsReminded = " + to_string(HK_BatchRemind) + ",";
    SQL += "AdvEnabled = " + to_string(HK_BatchAdv);
    SQL += " WHERE ID = " + to_string(HK_BatchID) + ";";
 
    Result.push_back(SQL);
    return Result;
}
 
 
int HK_Batch::CalculatePercent(int First, int Second)
{
    if (First == 0 || Second == 0)
        return 0;
 
    float Float1 = First;
    float Float2 = Second;
    float Float3 = Float1 / Float2;
    return Float3 * 100;
}
 
 
int HK_Batch::GetDaysLeft() {
    HK_Date d;
        
    if(HK_BatchStart.IsBefore(d))
        return HK_BatchStart.Difference(HK_BatchHatch);
    else if (HK_BatchHatch.IsAfter(d))
        return 0; 
    else
        return d.Difference(HK_BatchHatch);
}
 
int HK_Batch::OnDay() {
    HK_Date d;
        
    if(HK_BatchStart.IsBefore(d))
        return 0; 
    else if (HK_BatchHatch.IsAfter(d))
        return HK_BatchStart.Difference(HK_BatchHatch);
    else
        return d.Difference(HK_BatchStart);
}
 
int HK_Batch::PercentFertile()
{
    return CalculatePercent(GetFertile(),GetEggs());
}
 
int HK_Batch::PercentOfFertile()
{
    return CalculatePercent(GetChicks(),GetFertile());
}
 
int HK_Batch::PercentOfTotal()
{
    return CalculatePercent(GetChicks(),GetEggs());
}
 
int HK_Batch::FertileUnhatched()
{
    return (GetEggs() - GetChicks()) - (GetEggs() - GetFertile());
}
 
int HK_Batch::PercentOfTotalUnhatched()
{
    return CalculatePercent(GetEggs() - GetChicks(), GetEggs());
}