path: root/server/modules/downloaders/curl/main.cpp

/*
	Copyright © 2015 Gluzskiy Alexandr (sss)

    This file is part of Unknown Download Manager (UDM).

    UDM is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 2 of the License, or
    (at your option) any later version.

    UDM is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with UDM.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "main.h"
#include <boost/bind.hpp>
#include <boost/log/trivial.hpp>

#include <curl/curl.h>

#include "curl_download.h"



module_base::~module_base()
{
}


downloader::downloader()
{
	if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK)
	{
		//TODO: handle error
	}
}

downloader::~downloader()
{
	//TODO: stop downloads
	//TODO: deinit curl
	//save runtime state on exit
	{
        //we need to know id of last element in downloads map on loading, save it
        if(!downloads.empty())
        {
            char id_[32];
            snprintf(id_, 31, "%d", downloads.rbegin()->first);
            std::string val = id_;
            api->metadata_set(this, "id_of_last_download", std::vector<char>(val.begin(), val.end()));
        }
    }
}

std::string compute_var_name(int download_id, std::string setting_name)
{
	std::string var_name = "download_";
	char id_s[64];
	snprintf(id_s, 63, "%d", download_id);
	var_name += id_s;
	var_name += "_";
	var_name += setting_name;
	return var_name;
}


void downloader::on_modules_loaded()
{
	//TODO: load downloads, metadata, e.t.c.
	std::vector<char> val;
	api->metadata_get(this, "id_of_last_download", val);
	std::string s(val.begin(), val.end());
	int last = atoi(s.c_str());
	for(int i = 0; i <= last; i++)
	{
		//TODO: rework following, for now just sufficient code for testing
		std::vector<char> tmp;
		if(!api->metadata_get(this, compute_var_name(i, "name"), tmp)) //always required
			continue;
		if(tmp.empty())
			continue;
		tmp.clear();
		if(!api->metadata_get(this, compute_var_name(i, "download_path"), tmp)) //always required
			continue;
		if(tmp.empty())
			continue;
		tmp.clear();
		std::map<int, std::string> params;
		for(int p = 0;; p++)
		{
			char num_[32];
			snprintf(num_, 31, "%d", p);
			if(api->metadata_get(this, compute_var_name(i, std::string("param_") + num_), tmp))
			{
				params[p] = std::string(tmp.begin(), tmp.end());
				tmp.clear();
			}
			else
				break;
		}
		add_download(params); //TODO: implement better approach, but this should be ok for testing

	}

}

void downloader::load(core_api *a)
{
	api = a;

	info.name = "curl";
	info.description = "basic http/ftp downloader via libcurl, also example how to write downloader modules";
	info.version = "0.0.0.1draft";
	module_download_ui_element_info_s e;
	e.id = 0;
	e.name = "Url";
	e.type = MODULE_UI_ELEMENT_TYPE_e::UI_STR_;
	info.download_creation_ui.push_back(e);
	e.id = 1;
	e.name = "Download path";
	e.type = MODULE_UI_ELEMENT_TYPE_e::UI_STR_;
	info.download_creation_ui.push_back(e);
	info.on_modules_loaded = boost::bind(&downloader::on_modules_loaded, this); //optional definition of function which is called after all modules loaded
}

const module_info_base &downloader::get_module_info()
{
	return info;
}

void downloader::set_module_settings(const std::map<std::string, setting_s> &settings)
{
	this->settings = settings;
}

int downloader::add_download(std::map<int, std::string> params)
{
	if(params.find(0) == params.end()) //missed required parameter
		return -1;
	curl_download *d = new curl_download(params, api);
//	std::string download_name;
	{
		auto p1 = params[0].rfind("/");
		if(p1 != std::string::npos)
			d->name = params[0].substr(p1+1);
		else
		d->name = params[0];
	}
	int id = 0;
	if(!downloads.empty())
	{
		id = downloads.size();

		d->id = id;
	}
	else
		d->id = 0;

	downloads[id] = d;
	//store metadata
	{
		if(!api->metadata_set(this, compute_var_name(id, "name"), std::vector<char>(d->name.begin(), d->name.end())))
		{
			//TODO: handle error
		}
		if(!api->metadata_set(this, compute_var_name(id, "download_path"), std::vector<char>(d->get_download_path().begin(), d->get_download_path().end())))
		{
			//TODO: handle error
		}
		//store params
		for(auto i : params)
		{
			char num_[32];
			snprintf(num_, 31, "%d", i.first);
			if(!api->metadata_set(this, compute_var_name(id, std::string("param_") + num_), std::vector<char>(i.second.begin(), i.second.end())))
			{
				//TODO: handle error
			}
		}
	}
	//TODO:
	return id;
}

bool downloader::stop_download(int download_id)
{
	//TODO:
	bool status = downloads[download_id]->stop();
	if(!status)
	{
		//TODO: handle error
		return false;
	}
	return true;
}

bool downloader::start_download(int download_id)
{
	//TODO:
	bool status = downloads[download_id]->start();
	if(!status)
	{
		//TODO: handle error
		return false;
	}
	return true;
}

bool downloader::delete_download(int download_id, bool delete_data)
{
	bool status = downloads[download_id]->delete_download();
	if(!status)
	{
		//TODO: handle errror
		return false;
	}
	else
	{
		delete downloads[download_id];
		downloads.erase(download_id);
	}
	//TODO:
	return true;
}

bool downloader::execute_action_on_download(int download_id, int action_id)
{
	//TODO:
	return true;
}

std::list<download_s> downloader::get_downloads(std::map<int, std::string> params)
{
	std::list<download_s> l;
	for(auto i : downloads)
		l.push_back(*(i.second));
	//TODO: fill aditional data fields

	return l;
}

download_s downloader::get_download(int download_id, std::map<int, std::string> params)
{
	download_s d = *downloads[download_id];
	//TODO: fill additional data fields
	return d;
}


bool downloader::metadata_set(int download_id, std::map<std::string, std::string> metadata)
{
	downloads[download_id]->metadata = metadata;
    for(auto i : downloads[download_id]->metadata)
		api->metadata_set(this, compute_var_name(download_id, i.first), std::vector<char>(i.second.begin(), i.second.end()));
	return true;
}

bool downloader::metadata_update(int download_id, std::map<std::string, std::string> metadata)
{
	for(auto i : metadata)
		downloads[download_id]->metadata[i.first] = i.second;
    for(auto i : downloads[download_id]->metadata)
		api->metadata_set(this, compute_var_name(download_id, i.first), std::vector<char>(i.second.begin(), i.second.end()));
	return true;
}

bool downloader::metadata_drop(int download_id, std::string var)
{
	if(!var.empty())
	{
		downloads[download_id]->metadata.erase(var);
		api->metadata_remove(this, compute_var_name(download_id, var));
	}
	else
	{
		for(auto i : downloads[download_id]->metadata)
			api->metadata_remove(this, compute_var_name(download_id, i.first));
		downloads[download_id]->metadata.clear();
	}
	return true;
}
std::map<std::string, std::string> downloader::metadata_get(int download_id)
{
	return downloads[download_id]->metadata;
}

std::string downloader::metadata_get(int download_id, std::string var)
{
	auto i = downloads[download_id]->metadata.find(var);
	if(i != downloads[download_id]->metadata.end())
		return i->second;
	return std::string();
}



extern "C" module_downloader* udm_downloader_module_load()
{
	return new downloader;
}