static * createStory(data){
//if user is logged. this param is add by api-gateway
if (data.loggedUser) {
data.userId = data.loggedUser.id;
if(data.hideUser === true) {
logger.info('Hide User. Removing name and email');
data.name = '';
data.email = '';
}
}
let story = yield cartoDBService.createStory(data);
logger.debug('Saving new story in cache', story);
let storyFormat = StoryService.formatStory(story);
yield new Story(storyFormat).save();
logger.debug('Checking if email is defined to send email');
if(data.loggedUser){
let language = 'en';
let user = null;
if (data.loggedUser) {
logger.info('Obtaining user', '/user/' + data.loggedUser.id);
try {
let result = yield ctRegisterMicroservice.requestToMicroservice({
uri: '/user/' + data.loggedUser.id,
method: 'GET',
json: true
});
user = yield deserializer(result);
if (user.language) {
logger.info('Setting user language to send email');
language = user.language.toLowerCase().replace(/_/g, '-');
}
} catch(e) {
logger.error('error obtaining user',e);
}
}
let template = `${config.get('mailStory.template')}-${language}`;
mailService.sendMail(template, {
name: storyFormat.name,
story_url: config.get('mailStory.myStories')
},[{
address: user.email
}]);
logger.info('Email sended to user with template', template);
}
logger.info('sending email to WRI');
let wriRecipients = config.get('wriMailStory.recipients').split(',');
wriRecipients = wriRecipients.map(function(mail){
return {
address: mail
};
});
mailService.sendMail(config.get('wriMailStory.template'), {
story_url: config.get('mailStory.urlDetail') + storyFormat.id
},wriRecipients);
return StorySerializer.serialize(storyFormat);
}
static * executeQuery(query, beginDate, endDate, geostoreId, tableName, threshold){
let julianDayBegin = julian.toJulianDay(beginDate);
let yearBegin = beginDate.getFullYear();
let julianDayEnd = julian.toJulianDay(endDate);
let yearEnd = endDate.getFullYear();
let finalQuery = query.replace('{{begin}}', beginDate.toISOString().slice(0,10)).replace('{{end}}', endDate.toISOString().slice(0,10))
.replace('{{julianDayBegin}}', julianDayBegin).replace('{{yearBegin}}', yearBegin).replace('{{julianDayEnd}}', julianDayEnd).replace('{{yearEnd}}', yearEnd);
logger.debug('Doing query: ', finalQuery);
try {
const result = yield ctRegisterMicroservice.requestToMicroservice({
uri: '/query',
qs: {
sql: finalQuery,
threshold,
geostore: geostoreId
},
method: 'GET',
json: true
});
return result;
} catch(error) {
logger.error(error);
return null;
}
}
static * getGeostoreIdByParams(params){
try {
let uri = '/geostore';
if (params.use && params.useid) {
uri += `/use/${params.use}/${params.useid}`;
} else if (params.wdpaid){
uri += `/wdpa/${params.wdpaid}`;
} else {
if (params.iso && params.iso.country) {
if (params.iso && params.iso.region) {
uri += `/admin/${params.iso.country}/${params.iso.region}`;
} else {
uri += `/admin/${params.iso.country}`;
}
}
}
try {
logger.info('Uri', uri);
const result = yield ctRegisterMicroservice.requestToMicroservice({
uri: uri,
method: 'GET',
json: true
});
const geostore = yield deserializer(result);
return geostore.id;
} catch(error) {
logger.error(error);
return null;
}
} catch(error) {
logger.error(error);
return null;
}
}
static * execute(subscription, layerSlug, begin, end, forSubscription) {
logger.info('Executing analysis for', layerSlug, begin, end);
let period = formatDate(begin) + ',' + formatDate(end),
query = { period: period };
if (subscription.params.geostore) {
query.geostore = subscription.params.geostore;
}
if(forSubscription) {
query.forSubscription = true;
}
let path = AnalysisClassifier.pathFor(subscription, layerSlug),
url = '/' + layerSlug + path;
logger.debug('subscription id: ', subscription._id, 'Url ', url, 'and query ', query);
try {
let result = yield ctRegisterMicroservice.requestToMicroservice({
uri: url,
method: 'GET',
json: true,
qs: query
});
return yield deserializer(result);
} catch (e) {
logger.error(e);
return null;
}
}
static * getGeostoreIdByArea(idArea){
try {
logger.info('Obtaining area with id: ', idArea);
const result = yield ctRegisterMicroservice.requestToMicroservice({
uri: `/area/${idArea}`,
method: 'GET',
json: true
});
const area = yield deserializer(result);
logger.info('Area Result', area);
if (area.geostore) {
return area.geostore;
}
let uri = '/geostore';
if (area.use && area.use.name) {
uri += `/use/${area.use.name}/${area.use.id}`;
} else if (area.wdpaid){
uri += `/wdpa/${area.wdpaid}`;
} else {
if (area.iso) {
if (area.iso && area.iso.region) {
uri += `/admin/${area.iso.country}/${area.iso.region}`;
} else {
uri += `/admin/${area.iso.country}`;
}
}
}
try {
logger.info('Uri', uri);
const result = yield ctRegisterMicroservice.requestToMicroservice({
uri: uri,
method: 'GET',
json: true
});
const geostore = yield deserializer(result);
return geostore.id;
} catch(error) {
logger.error(error);
return null;
}
} catch(error) {
logger.error(error);
return null;
}
}
static * getMetadata(datasetId, application, language){
try {
const result = yield ctRegisterMicroservice.requestToMicroservice({
uri: `/dataset/${datasetId}/metadata?application=${application}&language=${language}`,
method: 'GET',
json: true
});
return result.data;
} catch(error) {
logger.error(error);
return null;
}
}
static * getDataset(datasetId){
try {
const result = yield ctRegisterMicroservice.requestToMicroservice({
uri: `/dataset/${datasetId}`,
method: 'GET',
json: true
});
return result.data.attributes;
} catch(error) {
logger.error(error);
return null;
}
}
* getGeojson(path){
let result = yield ctRegisterMicroservice.requestToMicroservice({
uri: path,
method: 'GET',
json: true
});
let geostore = yield deserializer(result);
if (geostore.geojson) {
return geostore.geojson.features[0].geometry;
} else {
throw new Error('Geostore not found');
}
}
static * getAreaName(idArea){
try {
logger.info('Obtaining area with id: ', idArea);
const result = yield ctRegisterMicroservice.requestToMicroservice({
uri: `/area/${idArea}`,
method: 'GET',
json: true
});
const area = yield deserializer(result);
return area.name;
} catch(error) {
logger.error(error);
return null;
}
}
static * getUser(id) {
try{
logger.debug('Doing request to /user');
let result = yield ctRegisterMicroservice.requestToMicroservice({
uri: '/user/' + id,
method: 'GET',
json: true
});
return yield deserializer(result);
}catch(e){
logger.error(e);
return null;
}
}
function* getBBoxQuery(client, subscription) {
if (subscription.params.iso && subscription.params.iso.country) {
if (!subscription.params.iso.region) {
let data = yield executeThunk(client, geoQuery.ISO_BBOX, {
iso: subscription.params.iso.country
});
return data.rows[0].bbox;
} else {
let data = yield executeThunk(client, geoQuery.ID1_BBOX, {
iso: subscription.params.iso.country,
id1: subscription.params.iso.region
});
return data.rows[0].bbox;
}
} else if (subscription.params.wdpaid) {
let data = yield executeThunk(client, geoQuery.WDPA_BBOX, {
wdpaid: subscription.params.wdpaid
});
return data.rows[0].bbox;
} else if (subscription.params.use) {
let data = yield executeThunk(client, geoQuery.USE_BBOX, {
use_table: subscription.params.use,
pid: subscription.params.useid
});
return data.rows[0].bbox;
} else if (subscription.params.geostore) {
try{
let result = yield ctRegisterMicroservice.requestToMicroservice({
uri: '/geostore/' + subscription.params.geostore,
method: 'GET',
json: true
});
let geostore = yield deserializer(result);
let data = yield executeThunk(client, geoQuery.WORLD_BBOX, {
geojson: JSON.stringify(geostore.geojson.features[0].geometry)
});
return data.rows[0].bbox;
} catch (e) {
logger.error('Error obtaining geostore', e);
return null;
}
}
}
static * getLastDateFromDataset(datasetSlug, datasetMainDateField){
const query = `select max(${datasetMainDateField}) as lastdate from ${datasetSlug}`;
logger.debug('Doing query: ', query);
try {
const result = yield ctRegisterMicroservice.requestToMicroservice({
uri: '/query',
qs: {
sql: query
},
method: 'GET',
json: true
});
return result.data[0].lastdate;
} catch(error) {
logger.error(error);
return null;
}
}
function* getQuery(subscription) {
if (subscription.params.iso && subscription.params.iso.country) {
if (!subscription.params.iso.region) {
return Mustache.render(geoQuery.ISO, {
iso: subscription.params.iso.country
});
} else {
return Mustache.render(geoQuery.ID1, {
iso: subscription.params.iso.country,
id1: subscription.params.iso.region
});
}
} else if (subscription.params.wdpaid) {
return Mustache.render(geoQuery.WDPA, {
wdpaid: subscription.params.wdpaid
});
} else if (subscription.params.use) {
return Mustache.render(geoQuery.USE, {
use_table: subscription.params.use,
pid: subscription.params.useid
});
} else if (subscription.params.geostore) {
try {
let result = yield ctRegisterMicroservice.requestToMicroservice({
uri: '/geostore/' + subscription.params.geostore,
method: 'GET',
json: true
});
let geostore = yield deserializer(result);
console.log(JSON.stringify(geostore.geojson.features[0].geometry));
return Mustache.render(geoQuery.WORLD, {
geojson: JSON.stringify(geostore.geojson.features[0].geometry).replace(/"/g, '\\"')
});
} catch(e){
logger.error(e);
return null;
}
}
}