Project

General

Profile

1
package eu.dnetlib.usagestats.repos;
2

    
3
import com.fasterxml.jackson.databind.ObjectMapper;
4

    
5
import eu.dnetlib.usagestats.portal.RepositoryStats;
6
import eu.dnetlib.usagestats.portal.UsageStats;
7
import eu.dnetlib.usagestats.sushilite.ItemIdentifier;
8
import eu.dnetlib.usagestats.sushilite.ItemPerformance;
9
import eu.dnetlib.usagestats.sushilite.ReportItem;
10

    
11
import org.apache.commons.dbutils.DbUtils;
12
import org.apache.log4j.Logger;
13
import org.springframework.beans.factory.annotation.Autowired;
14
import org.springframework.data.redis.core.HashOperations;
15

    
16
import javax.annotation.PostConstruct;
17
import javax.sql.DataSource;
18

    
19
import java.security.MessageDigest;
20
import java.sql.Connection;
21
import java.sql.PreparedStatement;
22
import java.sql.ResultSet;
23
import java.text.SimpleDateFormat;
24
import java.util.Calendar;
25
import java.util.Date;
26
import java.util.List;
27

    
28

    
29
public class BaseRepository {
30
    @Autowired
31
    private DataSourceBean dataSourceBean;
32

    
33
    private DataSource usageStatsDB;
34

    
35
    @Autowired
36
    private SpringRedisConfiguration springRedisConfiguration;
37

    
38
    //private RedisTemplate redisTemplate;
39

    
40
    private HashOperations<String, String, String> jedis;
41

    
42
    private final Logger log = Logger.getLogger(this.getClass());
43

    
44
    @PostConstruct
45
    public void initDB() {
46
        usageStatsDB = dataSourceBean.getDataSource();
47
        //redisTemplate = springRedisConfiguration.redisTemplate();
48
        //jedis = redisTemplate.opsForHash();
49
        jedis = springRedisConfiguration.redisTemplate().opsForHash();
50
    }
51

    
52
    /*
53
    private static Object fromString( String s ) throws Exception {
54
        byte [] data = Base64.getDecoder().decode( s );
55
        ObjectInputStream ois = new ObjectInputStream(
56
                new ByteArrayInputStream(  data ) );
57
        Object o  = ois.readObject();
58
        ois.close();
59
        return o;
60
    }
61

    
62
    private static String toString( Serializable o ) throws Exception {
63
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
64
        ObjectOutputStream oos = new ObjectOutputStream( baos );
65
        oos.writeObject( o );
66
        oos.close();
67
        return Base64.getEncoder().encodeToString(baos.toByteArray());
68
    }
69
    */
70

    
71
    private static String MD5(String string) throws java.security.NoSuchAlgorithmException {
72
        MessageDigest md = MessageDigest.getInstance("MD5");
73
        md.update(string.getBytes());
74

    
75
        byte byteData[] = md.digest();
76
        StringBuilder sb = new StringBuilder();
77
        for (byte aByteData : byteData) {
78
            sb.append(Integer.toString((aByteData & 0xff) + 0x100, 16).substring(1));
79
        }
80

    
81
        return sb.toString();
82
    }
83

    
84
    private static String toJson(Object o) throws com.fasterxml.jackson.core.JsonProcessingException {
85
        ObjectMapper objectMapper = new ObjectMapper();
86
        return objectMapper.writeValueAsString(o);
87
    }
88

    
89
    private static UsageStats fromJson(String string) throws java.io.IOException {
90
        ObjectMapper objectMapper = new ObjectMapper();
91
        return objectMapper.readValue(string, UsageStats.class);
92
    }
93

    
94
    /*
95
    private static List<ReportItem> reportItemsFromJson(String string) throws Exception {
96
        ObjectMapper objectMapper = new ObjectMapper();
97
        return objectMapper.readValue(string, objectMapper.getTypeFactory().constructCollectionType(List.class, ReportItem.class));
98
    }
99
    */
100

    
101
    UsageStats executeUsageStats(String query, List<String> values, String type) {
102
        //HashOperations jedis = redisTemplate.opsForHash();
103

    
104
        UsageStats usageStats = new UsageStats();
105
        int total_views = 0;
106
        int total_downloads = 0;
107
        int page_views = 0;
108
        int openaire_downloads = 0;
109
        int openaire_views = 0;
110
        Connection connection = null;
111
        PreparedStatement st = null;
112
        ResultSet rs = null;
113
        try {
114
            connection = usageStatsDB.getConnection();
115
            st = connection.prepareStatement(query);
116
            int i = 1;
117
            for (String s : values) {
118
                st.setString(i, s);
119
                i++;
120
            }
121

    
122
            String redis_key = MD5(st.toString());
123
            //String redis_key = Integer.toString(st.toString().hashCode());
124

    
125
            if (jedis.hasKey(redis_key, "result")) {
126
                //usageStats = (UsageStats) fromString((String) jedis.get(redis_key, "result"));
127
                usageStats = fromJson(jedis.get(redis_key, "result"));
128
                return usageStats;
129
            }
130

    
131
            rs = st.executeQuery();
132

    
133
            if (type.equals("result")) {
134
                while (rs.next()) {
135
                    if (rs.getString(1).equals("views") && rs.getString(4) != null && !rs.getString(4).equals("") && !rs.getString(4).equals("null")) {
136
                        usageStats.addViews(new RepositoryStats(rs.getString(3), rs.getString(2), rs.getString(4), rs.getString(5)));
137
                        total_views += Integer.parseInt(rs.getString(4));
138
                        openaire_views += Integer.parseInt(rs.getString(5));
139
                    } else if (rs.getString(1).equals("downloads") && rs.getString(4) != null && !rs.getString(4).equals("") && !rs.getString(4).equals("null")) {
140
                        usageStats.addDownloads(new RepositoryStats(rs.getString(3), rs.getString(2), rs.getString(4), "0"));
141
                        total_downloads += Integer.parseInt(rs.getString(4));
142
                        openaire_downloads += Integer.parseInt(rs.getString(5));
143
                    } else if (rs.getString(1).equals("pageviews") && rs.getString(4) != null && !rs.getString(4).equals("") && !rs.getString(4).equals("null")) {
144
                        page_views = Integer.parseInt(rs.getString(4));
145
                    }
146
                }
147
                usageStats.setTotal_views(Integer.toString(total_views));
148
                usageStats.setTotal_downloads(Integer.toString(total_downloads));
149
                usageStats.setPageViews(Integer.toString(page_views));
150
                usageStats.setTotal_openaire_views(Integer.toString(openaire_views));
151
                usageStats.setTotal_openaire_downloads(Integer.toString(openaire_downloads));
152
            } else if (type.equals("project") || type.equals("datasource")) {
153
                while (rs.next()) {
154
                    if (rs.getString(1).equals("views") && rs.getString(2) != null && !rs.getString(2).equals("") && !rs.getString(2).equals("null")) {
155
                        total_views += Integer.parseInt(rs.getString(2));
156
                        openaire_views += Integer.parseInt(rs.getString(3));
157
                    } else if (rs.getString(1).equals("downloads") && rs.getString(2) != null && !rs.getString(2).equals("") && !rs.getString(2).equals("null")) {
158
                        total_downloads += Integer.parseInt(rs.getString(2));
159
                        openaire_downloads += Integer.parseInt(rs.getString(3));
160
                    } else if (rs.getString(1).equals("pageviews") && rs.getString(2) != null && !rs.getString(2).equals("") && !rs.getString(2).equals("null")) {
161
                        page_views = Integer.parseInt(rs.getString(2));
162
                    }
163
                    /*
164
                    else if (rs.getString(1).equals("openaire") && rs.getString(2) != null && !rs.getString(2).equals("") && !rs.getString(2).equals("null")) {
165
                        openaire = Integer.parseInt(rs.getString(2));
166
                    }
167
                    */
168

    
169
                }
170
                usageStats.setTotal_views(Integer.toString(total_views));
171
                usageStats.setTotal_downloads(Integer.toString(total_downloads));
172
                usageStats.setPageViews(Integer.toString(page_views));
173
                usageStats.setTotal_openaire_views(Integer.toString(openaire_views));
174
                usageStats.setTotal_openaire_downloads(Integer.toString(openaire_downloads));
175
            }
176

    
177
            jedis.put(redis_key, "persistent", "false");
178
            jedis.put(redis_key, "query", st.toString());
179
            //jedis.put(redis_key, "result", toString(usageStats));
180
            jedis.put(redis_key, "result", toJson(usageStats));
181
            jedis.put(redis_key, "fetchMode", "3");
182

    
183
        } catch (Exception e) {
184
            log.error("Cannot execute query2 : ", e);
185

    
186
        } finally {
187
            DbUtils.closeQuietly(rs);
188
            DbUtils.closeQuietly(st);
189
            DbUtils.closeQuietly(connection);
190
        }
191
        return usageStats;
192
    }
193

    
194
    protected String executeRepoId(String repositoryIdentifier) {
195
        PreparedStatement st = null;
196
        Connection connection = null;
197
        ResultSet rs = null;
198
        try {
199
            connection = usageStatsDB.getConnection();
200
            String[] split = repositoryIdentifier.split(":");
201
            String openaire_id = "-1";
202
            switch (split[0].toLowerCase()) {
203
                case "openaire":
204
                    st = connection.prepareStatement("select id from datasource where id=?");
205
                    st.setString(1, repositoryIdentifier.replaceFirst(split[0] + ":", ""));
206

    
207
                    rs = st.executeQuery();
208
                    while (rs.next()) {
209
                        openaire_id = rs.getString(1);
210
                    }
211
                    return openaire_id;
212

    
213
                case "opendoar":
214
                    st = connection.prepareStatement("select id from datasource_oids where orid=?");
215
                    st.setString(1, "opendoar____::" + repositoryIdentifier.replaceFirst(split[0] + ":", ""));
216

    
217
                    rs = st.executeQuery();
218
                    while (rs.next()) {
219
                        openaire_id = rs.getString(1);
220
                    }
221
                    return openaire_id;
222
                default:
223
                    return "-1";
224
            }
225
        } catch (Exception e) {
226
            log.error("Repository id failed: ", e);
227
        } finally {
228
            DbUtils.closeQuietly(rs);
229
            DbUtils.closeQuietly(st);
230
            DbUtils.closeQuietly(connection);
231
        }
232
        return "-1";
233
    }
234

    
235
    protected void executeItem(List<ReportItem> reportItems, String itemIdentifier, String repositoryIdentifier, String itemDataType, Date beginDate, Date endDate, String granularity) {
236
        String[] split = itemIdentifier.split(":");
237
        switch (split[0].toLowerCase()) {
238
            case "oid":
239
                executeOid(reportItems, itemIdentifier.replaceFirst(split[0] + ":", ""), repositoryIdentifier, itemDataType, beginDate, endDate, granularity);
240
                break;
241
            case "doi":
242
                executeDoi(reportItems, itemIdentifier.replaceFirst(split[0] + ":", ""), repositoryIdentifier, itemDataType, beginDate, endDate, granularity);
243
                break;
244
            case "openaire":
245
                executeOpenaire(reportItems, itemIdentifier.replaceFirst(split[0] + ":", ""), repositoryIdentifier, itemDataType, beginDate, endDate, granularity);
246
                break;
247
            default:
248
        }
249
    }
250

    
251
    private void executeOid(List<ReportItem> reportItems, String oid, String repositoryIdentifier, String itemDataType, Date beginDate, Date endDate, String granularity) {
252
        Connection connection = null;
253
        PreparedStatement st = null;
254
        ResultSet rs = null;
255
        try {
256
            connection = usageStatsDB.getConnection();
257
            st = connection.prepareStatement("SELECT DISTINCT roid.id FROM result_oids roid, downloads_stats s WHERE s.result_id=roid.id AND roid.orid=? UNION SELECT DISTINCT roid.id FROM result_oids roid, views_stats s WHERE s.result_id=roid.id AND roid.orid=?");
258
            st.setString(1, oid);
259
            st.setString(2, oid);
260

    
261
            rs = st.executeQuery();
262

    
263
            while (rs.next()) {
264
                executeOpenaire(reportItems, rs.getString(1), repositoryIdentifier, itemDataType, beginDate, endDate, granularity);
265
            }
266
            connection.close();
267
        } catch (Exception e) {
268
            log.error("Oid to OpenAIRE id failed: ", e);
269
        } finally {
270
            DbUtils.closeQuietly(rs);
271
            DbUtils.closeQuietly(st);
272
            DbUtils.closeQuietly(connection);
273
        }
274
    }
275

    
276
    private void executeDoi(List<ReportItem> reportItems, String doi, String repositoryIdentifier, String itemDataType, Date beginDate, Date endDate, String granularity) {
277
        Connection connection = null;
278
        PreparedStatement st = null;
279
        ResultSet rs = null;
280
        try {
281
            connection = usageStatsDB.getConnection();
282
            st = connection.prepareStatement("SELECT DISTINCT poid.id FROM result_pids poid, downloads_stats s WHERE s.result_id=poid.id AND poid.type='doi' AND poid.pid=? UNION SELECT DISTINCT poid.id FROM result_pids poid, views_stats s WHERE s.result_id=poid.id AND poid.type='doi' AND poid.pid=?");
283
            st.setString(1, doi);
284
            st.setString(2, doi);
285

    
286
            rs = st.executeQuery();
287

    
288
            while (rs.next()) {
289
                executeOpenaire(reportItems, rs.getString(1), repositoryIdentifier, itemDataType, beginDate, endDate, granularity);
290
            }
291
        } catch (Exception e) {
292
            log.error("Doi to OpenAIRE id failed: ", e);
293
        } finally {
294
            DbUtils.closeQuietly(rs);
295
            DbUtils.closeQuietly(st);
296
            DbUtils.closeQuietly(connection);
297
        }
298
    }
299

    
300
    private void executeOpenaire(List<ReportItem> reportItems, String openaire, String repositoryIdentifier, String itemDataType, Date beginDate, Date endDate, String granularity) {
301
        SimpleDateFormat report_dateFormat = new SimpleDateFormat("yyyy-MM-dd");
302
        SimpleDateFormat postgresFormat = new SimpleDateFormat("yyyy/MM");
303
        String beginDateStr = postgresFormat.format(beginDate);
304
        String endDateStr = postgresFormat.format(endDate);
305

    
306
        Connection connection = null;
307
        PreparedStatement st = null;
308
        ResultSet rs = null;
309

    
310
        /*
311
        Calendar startCalendar = Calendar.getInstance();
312
        startCalendar.setTime(beginDate);
313
        Calendar endCalendar = Calendar.getInstance();
314
        endCalendar.setTime(endDate);
315
        int diffYear = endCalendar.get(Calendar.YEAR) - startCalendar.get(Calendar.YEAR);
316
        int diffMonth = diffYear * 12 + endCalendar.get(Calendar.MONTH) - startCalendar.get(Calendar.MONTH);
317
        */
318

    
319
        try {
320
            connection = usageStatsDB.getConnection();
321
            if (repositoryIdentifier.equals("")) {
322
                if (itemDataType.equals("")) {
323
                    st = connection.prepareStatement("SELECT res.repository_id, r.title, r.publisher, r.source, rc.type, pids.pid, d.name, res.ddate, oids.orid, res.downloads, res.views FROM (SELECT coalesce(ds.repository_id, vs.repository_id) AS repository_id, coalesce(ds.result_id, vs.result_id) AS result_id, coalesce(ds.date, vs.date) AS ddate, coalesce(ds.sum, 0) AS downloads, coalesce(vs.sum,0) AS views FROM (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM downloads_stats s WHERE s.date>=? AND s.date<=? AND s.result_id=? GROUP BY s.repository_id, s.result_id, s.date) AS ds FULL OUTER JOIN (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM views_stats s WHERE s.date>=? AND s.date<=? AND s.result_id=? GROUP BY s.repository_id, s.result_id, s.date) AS vs ON ds.result_id=vs.result_id AND ds.date=vs.date) AS res JOIN result r ON res.result_id=r.id JOIN datasource d ON d.id=res.repository_id JOIN result_classifications rc ON rc.id=r.id LEFT JOIN (SELECT pids.id, string_agg(pids.pid, '#!#') AS pid FROM result_pids pids WHERE pids.id=? AND type='doi' GROUP BY pids.id) AS pids ON pids.id=r.id LEFT JOIN (SELECT oids.id, string_agg(oids.orid, '#!#') AS orid FROM result_oids oids WHERE oids.id=? GROUP BY oids.id) AS oids ON oids.id=r.id ORDER BY res.repository_id, res.ddate;");
324
                    st.setString(1, beginDateStr);
325
                    st.setString(2, endDateStr);
326
                    st.setString(3, openaire);
327
                    st.setString(4, beginDateStr);
328
                    st.setString(5, endDateStr);
329
                    st.setString(6, openaire);
330
                    st.setString(7, openaire);
331
                    st.setString(8, openaire);
332
                } else {
333
                    st = connection.prepareStatement("SELECT res.repository_id, r.title, r.publisher, r.source, rc.type, pids.pid, d.name, res.ddate, oids.orid, res.downloads, res.views FROM (SELECT coalesce(ds.repository_id, vs.repository_id) AS repository_id, coalesce(ds.result_id, vs.result_id) AS result_id, coalesce(ds.date, vs.date) AS ddate, coalesce(ds.sum, 0) AS downloads, coalesce(vs.sum,0) AS views FROM (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM downloads_stats s WHERE s.date>=? AND s.date<=? AND s.result_id=? GROUP BY s.repository_id, s.result_id, s.date) AS ds FULL OUTER JOIN (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM views_stats s WHERE s.date>=? AND s.date<=? AND s.result_id=? GROUP BY s.repository_id, s.result_id, s.date) AS vs ON ds.result_id=vs.result_id AND ds.date=vs.date) AS res JOIN result r ON res.result_id=r.id JOIN datasource d ON d.id=res.repository_id JOIN result_classifications rc ON rc.id=r.id AND rc.type=? LEFT JOIN (SELECT pids.id, string_agg(pids.pid, '#!#') AS pid FROM result_pids pids WHERE pids.id=? AND type='doi' GROUP BY pids.id) AS pids ON pids.id=r.id LEFT JOIN (SELECT oids.id, string_agg(oids.orid, '#!#') AS orid FROM result_oids oids WHERE oids.id=? GROUP BY oids.id) AS oids ON oids.id=r.id ORDER BY res.repository_id, res.ddate;");
334
                    st.setString(1, beginDateStr);
335
                    st.setString(2, endDateStr);
336
                    st.setString(3, openaire);
337
                    st.setString(4, beginDateStr);
338
                    st.setString(5, endDateStr);
339
                    st.setString(6, openaire);
340
                    st.setString(7, itemDataType);
341
                    st.setString(8, openaire);
342
                    st.setString(9, openaire);
343
                }
344
            } else {
345
                if (itemDataType.equals("")) {
346
                    st = connection.prepareStatement("SELECT res.repository_id, r.title, r.publisher, r.source, rc.type, pids.pid, d.name, res.ddate, oids.orid, res.downloads, res.views FROM (SELECT coalesce(ds.repository_id, vs.repository_id) AS repository_id, coalesce(ds.result_id, vs.result_id) AS result_id, coalesce(ds.date, vs.date) AS ddate, coalesce(ds.sum, 0) AS downloads, coalesce(vs.sum,0) AS views FROM (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM downloads_stats s WHERE s.date>=? AND s.date<=? AND s.result_id=? AND s.repository_id=? GROUP BY s.repository_id, s.result_id, s.date) AS ds FULL OUTER JOIN (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM views_stats s WHERE s.date>=? AND s.date<=? AND s.result_id=? AND s.repository_id=? GROUP BY s.repository_id, s.result_id, s.date) AS vs ON ds.result_id=vs.result_id AND ds.date=vs.date) AS res JOIN result r ON res.result_id=r.id JOIN datasource d ON d.id=res.repository_id JOIN result_classifications rc ON rc.id=r.id LEFT JOIN (SELECT pids.id, string_agg(pids.pid, '#!#') AS pid FROM result_pids pids WHERE pids.id=? AND type='doi' GROUP BY pids.id) AS pids ON pids.id=r.id LEFT JOIN (SELECT oids.id, string_agg(oids.orid, '#!#') AS orid FROM result_oids oids WHERE oids.id=? GROUP BY oids.id) AS oids ON oids.id=r.id ORDER BY res.repository_id, res.ddate;");
347
                    st.setString(1, beginDateStr);
348
                    st.setString(2, endDateStr);
349
                    st.setString(3, openaire);
350
                    st.setString(4, repositoryIdentifier);
351
                    st.setString(5, beginDateStr);
352
                    st.setString(6, endDateStr);
353
                    st.setString(7, openaire);
354
                    st.setString(8, repositoryIdentifier);
355
                    st.setString(9, openaire);
356
                    st.setString(10, openaire);
357
                } else {
358
                    st = connection.prepareStatement("SELECT res.repository_id, r.title, r.publisher, r.source, rc.type, pids.pid, d.name, res.ddate, oids.orid, res.downloads, res.views FROM (SELECT coalesce(ds.repository_id, vs.repository_id) AS repository_id, coalesce(ds.result_id, vs.result_id) AS result_id, coalesce(ds.date, vs.date) AS ddate, coalesce(ds.sum, 0) AS downloads, coalesce(vs.sum,0) AS views FROM (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM downloads_stats s WHERE s.date>=? AND s.date<=? AND s.result_id=? AND s.repository_id=? GROUP BY s.repository_id, s.result_id, s.date) AS ds FULL OUTER JOIN (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM views_stats s WHERE s.date>=? AND s.date<=? AND s.result_id=? AND s.repository_id=? GROUP BY s.repository_id, s.result_id, s.date) AS vs ON ds.result_id=vs.result_id AND ds.date=vs.date) AS res JOIN result r ON res.result_id=r.id JOIN datasource d ON d.id=res.repository_id JOIN result_classifications rc ON rc.id=r.id AND rc.type=? LEFT JOIN (SELECT pids.id, string_agg(pids.pid, '#!#') AS pid FROM result_pids pids WHERE pids.id=? AND type='doi' GROUP BY pids.id) AS pids ON pids.id=r.id LEFT JOIN (SELECT oids.id, string_agg(oids.orid, '#!#') AS orid FROM result_oids oids WHERE oids.id=? GROUP BY oids.id) AS oids ON oids.id=r.id ORDER BY res.repository_id, res.ddate;");
359
                    st.setString(1, beginDateStr);
360
                    st.setString(2, endDateStr);
361
                    st.setString(3, openaire);
362
                    st.setString(4, repositoryIdentifier);
363
                    st.setString(5, beginDateStr);
364
                    st.setString(6, endDateStr);
365
                    st.setString(7, openaire);
366
                    st.setString(8, repositoryIdentifier);
367
                    st.setString(9, itemDataType);
368
                    st.setString(10, openaire);
369
                    st.setString(11, openaire);
370
                }
371
            }
372

    
373
            rs = st.executeQuery();
374
            String repository = "";
375
            String lastDate = "";
376
            ReportItem reportItem = null;
377
            int ft_total = 0;
378
            int abstr = 0;
379

    
380
            if (granularity.equalsIgnoreCase("totals")) {
381
                while (rs.next()) {
382
                    if (!rs.getString(1).equals(repository)) {
383
                        if (reportItem != null) {
384
                            reportItem.addPerformance(new ItemPerformance(report_dateFormat.format(beginDate), report_dateFormat.format(endDate), Integer.toString(ft_total), Integer.toString(abstr)));
385
                            reportItems.add(reportItem);
386
                        }
387
                        repository = rs.getString(1);
388
                        reportItem = new ReportItem(rs.getString(3), rs.getString(7), rs.getString(5), rs.getString(2));
389
                        reportItem.addIdentifier(new ItemIdentifier("OpenAIRE", openaire));
390
                        reportItem.addIdentifier(new ItemIdentifier("URLs", rs.getString(4)));
391
                        if (rs.getString(9) != null && !rs.getString(9).equals("")) {
392
                            if (rs.getString(9).contains("#!#")) {
393
                                reportItem.addIdentifier(new ItemIdentifier("OAI", rs.getString(9).substring(0, rs.getString(9).indexOf("#!#"))));
394
                            } else {
395
                                reportItem.addIdentifier(new ItemIdentifier("OAI", rs.getString(9)));
396
                            }
397
                        }
398
                        if (rs.getString(6) != null && !rs.getString(6).equals("")) {
399
                            if (rs.getString(6).contains("#!#")) {
400
                                reportItem.addIdentifier(new ItemIdentifier("DOI", rs.getString(6).substring(0, rs.getString(6).indexOf("#!#"))));
401
                            } else {
402
                                reportItem.addIdentifier(new ItemIdentifier("DOI", rs.getString(6)));
403
                            }
404
                        }
405
                        ft_total = 0;
406
                        abstr = 0;
407
                    }
408
                    ft_total += rs.getInt(10);
409
                    abstr += rs.getInt(11);
410
                }
411
                if (reportItem != null) {
412
                    reportItem.addPerformance(new ItemPerformance(report_dateFormat.format(beginDate), report_dateFormat.format(endDate), Integer.toString(ft_total), Integer.toString(abstr)));
413
                    reportItems.add(reportItem);
414
                }
415
            } else if (granularity.equalsIgnoreCase("monthly")) {
416
                Calendar endCal = Calendar.getInstance();
417
                endCal.setTime(postgresFormat.parse(endDateStr));
418
                endCal.add(Calendar.MONTH, 1);
419
                Date endDateForZeros = endCal.getTime();
420
                while (rs.next()) {
421
                    if (!rs.getString(1).equals(repository)) {
422
                        if (reportItem != null) {
423
                            fillWithZeros(postgresFormat.parse(lastDate), endDateForZeros, reportItem);
424
                            reportItems.add(reportItem);
425
                        }
426
                        repository = rs.getString(1);
427
                        lastDate = beginDateStr;
428
                        reportItem = new ReportItem(rs.getString(3), rs.getString(7), rs.getString(5), rs.getString(2));
429
                        reportItem.addIdentifier(new ItemIdentifier("OpenAIRE", openaire));
430
                        reportItem.addIdentifier(new ItemIdentifier("URLs", rs.getString(4)));
431
                        if (rs.getString(9) != null && !rs.getString(9).equals("")) {
432
                            if (rs.getString(9).contains("#!#")) {
433
                                reportItem.addIdentifier(new ItemIdentifier("OAI", rs.getString(9).substring(0, rs.getString(9).indexOf("#!#"))));
434
                            } else {
435
                                reportItem.addIdentifier(new ItemIdentifier("OAI", rs.getString(9)));
436
                            }
437
                        }
438
                        if (rs.getString(6) != null && !rs.getString(6).equals("")) {
439
                            if (rs.getString(6).contains("#!#")) {
440
                                reportItem.addIdentifier(new ItemIdentifier("DOI", rs.getString(6).substring(0, rs.getString(6).indexOf("#!#"))));
441
                            } else {
442
                                reportItem.addIdentifier(new ItemIdentifier("DOI", rs.getString(6)));
443
                            }
444
                        }
445
                    }
446
                    fillWithZeros(postgresFormat.parse(lastDate), postgresFormat.parse(rs.getString(8)), reportItem);
447
                    Calendar endC = Calendar.getInstance();
448
                    endC.setTime(postgresFormat.parse(rs.getString(8)));
449
                    endC.set(Calendar.DATE, endC.getActualMaximum(Calendar.DATE));
450
                    if (reportItem != null) {
451
                        reportItem.addPerformance(new ItemPerformance(report_dateFormat.format(postgresFormat.parse(rs.getString(8))), report_dateFormat.format(endC.getTime()), rs.getString(10), rs.getString(11)));
452
                    }
453
                    endC.setTime(postgresFormat.parse(rs.getString(8)));
454
                    endC.add(Calendar.MONTH, 1);
455
                    lastDate = postgresFormat.format(endC.getTime());
456
                }
457
                if (reportItem != null) {
458
                    fillWithZeros(postgresFormat.parse(lastDate), endDateForZeros, reportItem);
459
                    reportItems.add(reportItem);
460
                }
461
            }
462
        } catch (Exception e) {
463
            log.error("Single Item Report failed: ", e);
464
        } finally {
465
            DbUtils.closeQuietly(rs);
466
            DbUtils.closeQuietly(st);
467
            DbUtils.closeQuietly(connection);
468
        }
469
    }
470

    
471
    protected void executeRepo(List<ReportItem> reportItems, String repositoryIdentifier, String itemDataType, Date beginDate, Date endDate, String granularity) {
472
        SimpleDateFormat report_dateFormat = new SimpleDateFormat("yyyy-MM-dd");
473
        SimpleDateFormat postgresFormat = new SimpleDateFormat("yyyy/MM");
474
        String beginDateStr = postgresFormat.format(beginDate);
475
        String endDateStr = postgresFormat.format(endDate);
476

    
477
        Connection connection = null;
478
        PreparedStatement st = null;
479
        ResultSet rs = null;
480

    
481
        try {
482
            connection = usageStatsDB.getConnection();
483

    
484
            if (repositoryIdentifier.equals("")) {
485
                if (itemDataType.equals("")) {
486
                    st = connection.prepareStatement("SELECT d.id, d.name, d.websiteurl, dois.orid, res.ddate, res.downloads, res.views FROM (SELECT coalesce(ds.source, vs.source), coalesce(ds.repository_id, vs.repository_id) AS repository_id, coalesce(ds.date, vs.date) AS ddate, coalesce(ds.sum, 0) AS downloads, coalesce(vs.sum,0) AS views FROM (SELECT s.source, s.repository_id, s.date, sum(s.count) FROM downloads_stats s WHERE s.date>=? AND s.date<=? GROUP BY s.source, s.repository_id, s.date) AS ds FULL OUTER JOIN (SELECT s.source, s.repository_id, s.date, sum(s.count) FROM views_stats s WHERE s.date>=? AND s.date<=? GROUP BY s.source, s.repository_id, s.date) AS vs ON ds.source=vs.source AND ds.repository_id=vs.repository_id AND ds.date=vs.date) AS res JOIN datasource d ON d.id=res.repository_id JOIN datasource_oids dois ON d.id=dois.id WHERE dois.orid LIKE 'opendoar%' ORDER BY d.id, d.name, res.ddate ASC;");
487
                    st.setString(1, beginDateStr);
488
                    st.setString(2, endDateStr);
489
                    st.setString(3, beginDateStr);
490
                    st.setString(4, endDateStr);
491
                } else {
492
                    st = connection.prepareStatement("SELECT d.id, d.name, d.websiteurl, dois.orid, res.ddate, res.downloads, res.views FROM (SELECT coalesce(ds.source, vs.source), coalesce(ds.repository_id, vs.repository_id) AS repository_id, coalesce(ds.date, vs.date) AS ddate, coalesce(ds.sum, 0) AS downloads, coalesce(vs.sum,0) AS views FROM (SELECT s.source, s.repository_id, s.date, sum(s.count) FROM downloads_stats s, result_classifications rc WHERE rc.id=s.result_id AND s.date>=? AND s.date<=? AND rc.type=? GROUP BY s.source, s.repository_id, s.date) AS ds FULL OUTER JOIN (SELECT s.source, s.repository_id, s.date, sum(s.count) FROM views_stats s, result_classifications rc WHERE rc.id=s.result_id AND s.date>=? AND s.date<=? AND rc.type=? GROUP BY s.source, s.repository_id, s.date) AS vs ON ds.source=vs.source AND ds.repository_id=vs.repository_id AND ds.date=vs.date) AS res JOIN datasource d ON d.id=res.repository_id JOIN datasource_oids dois ON d.id=dois.id WHERE dois.orid LIKE 'opendoar%' ORDER BY d.id, d.name, res.ddate ASC;");
493
                    st.setString(1, beginDateStr);
494
                    st.setString(2, endDateStr);
495
                    st.setString(3, itemDataType);
496
                    st.setString(4, beginDateStr);
497
                    st.setString(5, endDateStr);
498
                    st.setString(6, itemDataType);
499
                }
500
            } else {
501
                if (itemDataType.equals("")) {
502
                    st = connection.prepareStatement("SELECT d.id, d.name, d.websiteurl, dois.orid, res.ddate, res.downloads, res.views FROM (SELECT coalesce(ds.source, vs.source), coalesce(ds.repository_id, vs.repository_id) AS repository_id, coalesce(ds.date, vs.date) AS ddate, coalesce(ds.sum, 0) AS downloads, coalesce(vs.sum,0) AS views FROM (SELECT s.source, s.repository_id, s.date, sum(s.count) FROM downloads_stats s WHERE s.date>=? AND s.date<=? AND s.repository_id=? GROUP BY s.source, s.repository_id, s.date) AS ds FULL OUTER JOIN (SELECT s.source, s.repository_id, s.date, sum(s.count) FROM views_stats s WHERE s.date>=? AND s.date<=? AND s.repository_id=? GROUP BY s.source, s.repository_id, s.date) AS vs ON ds.source=vs.source AND ds.repository_id=vs.repository_id AND ds.date=vs.date) AS res JOIN datasource d ON d.id=res.repository_id JOIN datasource_oids dois ON d.id=dois.id WHERE dois.orid LIKE 'opendoar%' ORDER BY d.id, d.name, res.ddate ASC;");
503
                    st.setString(1, beginDateStr);
504
                    st.setString(2, endDateStr);
505
                    st.setString(3, repositoryIdentifier);
506
                    st.setString(4, beginDateStr);
507
                    st.setString(5, endDateStr);
508
                    st.setString(6, repositoryIdentifier);
509
                } else {
510
                    st = connection.prepareStatement("SELECT d.id, d.name, d.websiteurl, dois.orid, res.ddate, res.downloads, res.views FROM (SELECT coalesce(ds.source, vs.source), coalesce(ds.repository_id, vs.repository_id) AS repository_id, coalesce(ds.date, vs.date) AS ddate, coalesce(ds.sum, 0) AS downloads, coalesce(vs.sum,0) AS views FROM (SELECT s.source, s.repository_id, s.date, sum(s.count) FROM downloads_stats s, result_classifications rc WHERE rc.id=s.result_id AND s.date>=? AND s.date<=? AND rc.type=? AND s.repository_id=? GROUP BY s.source, s.repository_id, s.date) AS ds FULL OUTER JOIN (SELECT s.source, s.repository_id, s.date, sum(s.count) FROM views_stats s, result_classifications rc WHERE rc.id=s.result_id AND s.date>=? AND s.date<=? AND rc.type=? AND s.repository_id=? GROUP BY s.source, s.repository_id, s.date) AS vs ON ds.source=vs.source AND ds.repository_id=vs.repository_id AND ds.date=vs.date) AS res JOIN datasource d ON d.id=res.repository_id JOIN datasource_oids dois ON d.id=dois.id WHERE dois.orid LIKE 'opendoar%' ORDER BY d.id, d.name, res.ddate ASC;");
511
                    st.setString(1, beginDateStr);
512
                    st.setString(2, endDateStr);
513
                    st.setString(3, itemDataType);
514
                    st.setString(4, repositoryIdentifier);
515
                    st.setString(5, beginDateStr);
516
                    st.setString(6, endDateStr);
517
                    st.setString(7, itemDataType);
518
                    st.setString(8, repositoryIdentifier);
519
                }
520
            }
521
            //log.error("RR STATEMENT:   " + st);
522

    
523
            /*
524
            String redis_key = MD5(st.toString());
525

    
526
            if (jedis.hasKey(redis_key, "result")) {
527
                reportItems.addAll(reportItemsFromJson((String) jedis.get(redis_key, "result")));
528
                st.close();
529
                connection.close();
530
                return;
531
            }
532
            */
533

    
534
            rs = st.executeQuery();
535
            String repository = "";
536
            String lastDate = "";
537
            ReportItem reportItem = null;
538

    
539
            /*
540
            Calendar startCalendar = Calendar.getInstance();
541
            startCalendar.setTime(beginDate);
542
            Calendar endCalendar = Calendar.getInstance();
543
            endCalendar.setTime(endDate);
544
            */
545

    
546
            int ft_total = 0;
547
            int abstr = 0;
548
            if (granularity.equalsIgnoreCase("totals")) {
549
                while (rs.next()) {
550
                    if (!rs.getString(1).equals(repository)) {
551
                        if (reportItem != null) {
552
                            reportItem.addPerformance(new ItemPerformance(report_dateFormat.format(beginDate), report_dateFormat.format(endDate), Integer.toString(ft_total), Integer.toString(abstr)));
553
                            reportItems.add(reportItem);
554
                        }
555
                        repository = rs.getString(1);
556
                        reportItem = new ReportItem(null, rs.getString(2), "Platform", null);
557
                        reportItem.addIdentifier(new ItemIdentifier("OpenAIRE", rs.getString(1)));
558
                        reportItem.addIdentifier(new ItemIdentifier("OpenDOAR", rs.getString(4).substring(rs.getString(4).lastIndexOf(":") + 1)));
559
                        reportItem.addIdentifier(new ItemIdentifier("URL", rs.getString(3)));
560
                        ft_total = 0;
561
                        abstr = 0;
562
                    }
563
                    ft_total += rs.getInt(6);
564
                    abstr += rs.getInt(7);
565
                }
566
                if (reportItem != null) {
567
                    reportItem.addPerformance(new ItemPerformance(report_dateFormat.format(beginDate), report_dateFormat.format(endDate), Integer.toString(ft_total), Integer.toString(abstr)));
568
                    reportItems.add(reportItem);
569
                }
570
            } else if (granularity.equalsIgnoreCase("monthly")) {
571
                Calendar endCal = Calendar.getInstance();
572
                endCal.setTime(postgresFormat.parse(endDateStr));
573
                endCal.add(Calendar.MONTH, 1);
574
                Date endDateForZeros = endCal.getTime();
575
                while (rs.next()) {
576
                    if (!rs.getString(1).equals(repository)) {
577
                        if (reportItem != null) {
578
                            fillWithZeros(postgresFormat.parse(lastDate), endDateForZeros, reportItem);
579
                            reportItems.add(reportItem);
580
                        }
581
                        repository = rs.getString(1);
582
                        lastDate = beginDateStr;
583
                        reportItem = new ReportItem(null, rs.getString(2), "Platform", null);
584
                        reportItem.addIdentifier(new ItemIdentifier("OpenAIRE", rs.getString(1)));
585
                        reportItem.addIdentifier(new ItemIdentifier("OpenDOAR", rs.getString(4).substring(rs.getString(4).lastIndexOf(":") + 1)));
586
                        reportItem.addIdentifier(new ItemIdentifier("URL", rs.getString(3)));
587
                    }
588
                    fillWithZeros(postgresFormat.parse(lastDate), postgresFormat.parse(rs.getString(5)), reportItem);
589
                    Calendar endC = Calendar.getInstance();
590
                    endC.setTime(postgresFormat.parse(rs.getString(5)));
591
                    endC.set(Calendar.DATE, endC.getActualMaximum(Calendar.DATE));
592
                    if (reportItem != null) {
593
                        reportItem.addPerformance(new ItemPerformance(report_dateFormat.format(postgresFormat.parse(rs.getString(5))), report_dateFormat.format(endC.getTime()), rs.getString(6), rs.getString(7)));
594
                    }
595
                    endC.setTime(postgresFormat.parse(rs.getString(5)));
596
                    endC.add(Calendar.MONTH, 1);
597
                    lastDate = postgresFormat.format(endC.getTime());
598
                }
599
                if (reportItem != null) {
600
                    fillWithZeros(postgresFormat.parse(lastDate), endDateForZeros, reportItem);
601
                    reportItems.add(reportItem);
602
                }
603
            }
604

    
605
            /*
606
            jedis.put(redis_key, "persistent", "false");
607
            jedis.put(redis_key, "query", st.toString());
608
            jedis.put(redis_key, "result", toJson(reportItems));
609
            jedis.put(redis_key, "fetchMode", "3");
610
            */
611

    
612
            rs.close();
613
            st.close();
614
            connection.close();
615
        } catch (Exception e) {
616
            log.error("Repository Report failed: ", e);
617
        } finally {
618
            DbUtils.closeQuietly(rs);
619
            DbUtils.closeQuietly(st);
620
            DbUtils.closeQuietly(connection);
621
        }
622
    }
623

    
624
    protected void executeBatchItems(List<ReportItem> reportItems, String repositoryIdentifier, String itemDataType, Date beginDate, Date endDate, String granularity) {
625
        SimpleDateFormat report_dateFormat = new SimpleDateFormat("yyyy-MM-dd");
626
        SimpleDateFormat postgresFormat = new SimpleDateFormat("yyyy/MM");
627
        String beginDateStr = postgresFormat.format(beginDate);
628
        String endDateStr = postgresFormat.format(endDate);
629

    
630
        Connection connection = null;
631
        PreparedStatement st = null;
632
        ResultSet rs = null;
633

    
634
        try {
635
            connection = usageStatsDB.getConnection();
636

    
637
            if (itemDataType.equals("")) {
638
                st = connection.prepareStatement("SELECT res.result_id, r.title, r.publisher, r.source, rc.type, pids.pid, d.name, res.ddate, oids.orid, res.downloads, res.views FROM (SELECT coalesce(ds.repository_id, vs.repository_id) AS repository_id, coalesce(ds.result_id, vs.result_id) AS result_id, coalesce(ds.date, vs.date) AS ddate, coalesce(ds.sum, 0) AS downloads, coalesce(vs.sum,0) AS views FROM (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM downloads_stats s WHERE s.date>=? AND s.date<=? AND s.repository_id=? GROUP BY s.repository_id, s.result_id, s.date) AS ds FULL OUTER JOIN (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM views_stats s WHERE s.date>=? AND s.date<=? AND s.repository_id=? GROUP BY s.repository_id, s.result_id, s.date) AS vs ON ds.result_id=vs.result_id AND ds.date=vs.date) AS res JOIN result r ON res.result_id=r.id JOIN datasource d ON d.id=res.repository_id JOIN result_classifications rc ON rc.id=r.id LEFT JOIN (SELECT pids.id, string_agg(pids.pid, '#!#') AS pid FROM result_pids pids, result_datasources rd WHERE rd.id=pids.id AND type='doi' AND rd.datasource=? GROUP BY pids.id) AS pids ON pids.id=r.id LEFT JOIN (SELECT oids.id, string_agg(oids.orid, '#!#') AS orid FROM result_oids oids, result_datasources rd WHERE rd.id=oids.id AND rd.datasource=? GROUP BY oids.id) AS oids ON oids.id=r.id ORDER BY res.result_id, res.ddate;");
639
                st.setString(1, beginDateStr);
640
                st.setString(2, endDateStr);
641
                st.setString(3, repositoryIdentifier);
642
                st.setString(4, beginDateStr);
643
                st.setString(5, endDateStr);
644
                st.setString(6, repositoryIdentifier);
645
                st.setString(7, repositoryIdentifier);
646
                st.setString(8, repositoryIdentifier);
647
            } else {
648
                st = connection.prepareStatement("SELECT res.result_id, r.title, r.publisher, r.source, rc.type, pids.pid, d.name, res.ddate, oids.orid, res.downloads, res.views FROM (SELECT coalesce(ds.repository_id, vs.repository_id) AS repository_id, coalesce(ds.result_id, vs.result_id) AS result_id, coalesce(ds.date, vs.date) AS ddate, coalesce(ds.sum, 0) AS downloads, coalesce(vs.sum,0) AS views FROM (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM downloads_stats s WHERE s.date>=? AND s.date<=? AND s.repository_id=? GROUP BY s.repository_id, s.result_id, s.date) AS ds FULL OUTER JOIN (SELECT s.repository_id, s.result_id, s.date, sum(s.count) FROM views_stats s WHERE s.date>=? AND s.date<=? AND s.repository_id=? GROUP BY s.repository_id, s.result_id, s.date) AS vs ON ds.result_id=vs.result_id AND ds.date=vs.date) AS res JOIN result r ON res.result_id=r.id JOIN datasource d ON d.id=res.repository_id JOIN result_classifications rc ON rc.id=r.id LEFT JOIN (SELECT pids.id, string_agg(pids.pid, '#!#') AS pid FROM result_pids pids, result_datasources rd WHERE rd.id=pids.id AND type='doi' AND rd.datasource=? GROUP BY pids.id) AS pids ON pids.id=r.id LEFT JOIN (SELECT oids.id, string_agg(oids.orid, '#!#') AS orid FROM result_oids oids, result_datasources rd WHERE rd.id=oids.id AND rd.datasource=? GROUP BY oids.id) AS oids ON oids.id=r.id WHERE rc.type=? ORDER BY res.result_id, res.ddate;");
649
                st.setString(1, beginDateStr);
650
                st.setString(2, endDateStr);
651
                st.setString(3, repositoryIdentifier);
652
                st.setString(4, beginDateStr);
653
                st.setString(5, endDateStr);
654
                st.setString(6, repositoryIdentifier);
655
                st.setString(7, repositoryIdentifier);
656
                st.setString(8, repositoryIdentifier);
657
                st.setString(9, itemDataType);
658
            }
659
            //log.error("IR STATEMENT:   " + st);
660

    
661
            /*
662
            String redis_key = MD5(st.toString());
663

    
664
            if (jedis.hasKey(redis_key, "result")) {
665
                reportItems.addAll(reportItemsFromJson((String) jedis.get(redis_key, "result")));
666
                st.close();
667
                connection.close();
668
                return;
669
            }
670
            */
671

    
672
            rs = st.executeQuery();
673
            String result = "";
674
            String lastDate = "";
675
            ReportItem reportItem = null;
676

    
677
            int ft_total = 0;
678
            int abstr = 0;
679
            if (granularity.equalsIgnoreCase("totals")) {
680
                while (rs.next()) {
681
                    if (!rs.getString(1).equals(result)) {
682
                        if (reportItem != null) {
683
                            reportItem.addPerformance(new ItemPerformance(report_dateFormat.format(beginDate), report_dateFormat.format(endDate), Integer.toString(ft_total), Integer.toString(abstr)));
684
                            reportItems.add(reportItem);
685
                        }
686
                        result = rs.getString(1);
687
                        reportItem = new ReportItem(rs.getString(3), rs.getString(7), rs.getString(5), rs.getString(2));
688
                        reportItem.addIdentifier(new ItemIdentifier("OpenAIRE", rs.getString(1)));
689
                        reportItem.addIdentifier(new ItemIdentifier("URLs", rs.getString(4)));
690
                        if (rs.getString(9) != null && !rs.getString(9).equals("")) {
691
                            if (rs.getString(9).contains("#!#")) {
692
                                reportItem.addIdentifier(new ItemIdentifier("OAI", rs.getString(9).substring(0, rs.getString(9).indexOf("#!#"))));
693
                            } else {
694
                                reportItem.addIdentifier(new ItemIdentifier("OAI", rs.getString(9)));
695
                            }
696
                        }
697
                        if (rs.getString(6) != null && !rs.getString(6).equals("")) {
698
                            if (rs.getString(6).contains("#!#")) {
699
                                reportItem.addIdentifier(new ItemIdentifier("DOI", rs.getString(6).substring(0, rs.getString(6).indexOf("#!#"))));
700
                            } else {
701
                                reportItem.addIdentifier(new ItemIdentifier("DOI", rs.getString(6)));
702
                            }
703
                        }
704
                        ft_total = 0;
705
                        abstr = 0;
706
                    }
707
                    ft_total += rs.getInt(10);
708
                    abstr += rs.getInt(11);
709
                }
710
                if (reportItem != null) {
711
                    reportItem.addPerformance(new ItemPerformance(report_dateFormat.format(beginDate), report_dateFormat.format(endDate), Integer.toString(ft_total), Integer.toString(abstr)));
712
                    reportItems.add(reportItem);
713
                }
714
            } else if (granularity.equalsIgnoreCase("monthly")) {
715
                Calendar endCal = Calendar.getInstance();
716
                endCal.setTime(postgresFormat.parse(endDateStr));
717
                endCal.add(Calendar.MONTH, 1);
718
                Date endDateForZeros = endCal.getTime();
719
                while (rs.next()) {
720
                    if (!rs.getString(1).equals(result)) {
721
                        if (reportItem != null) {
722
                            fillWithZeros(postgresFormat.parse(lastDate), endDateForZeros, reportItem);
723
                            reportItems.add(reportItem);
724
                        }
725
                        result = rs.getString(1);
726
                        lastDate = beginDateStr;
727
                        reportItem = new ReportItem(rs.getString(3), rs.getString(7), rs.getString(5), rs.getString(2));
728
                        reportItem.addIdentifier(new ItemIdentifier("OpenAIRE", rs.getString(1)));
729
                        reportItem.addIdentifier(new ItemIdentifier("URLs", rs.getString(4)));
730
                        if (rs.getString(9) != null && !rs.getString(9).equals("")) {
731
                            if (rs.getString(9).contains("#!#")) {
732
                                reportItem.addIdentifier(new ItemIdentifier("OAI", rs.getString(9).substring(0, rs.getString(9).indexOf("#!#"))));
733
                            } else {
734
                                reportItem.addIdentifier(new ItemIdentifier("OAI", rs.getString(9)));
735
                            }
736
                        }
737
                        if (rs.getString(6) != null && !rs.getString(6).equals("")) {
738
                            if (rs.getString(6).contains("#!#")) {
739
                                reportItem.addIdentifier(new ItemIdentifier("DOI", rs.getString(6).substring(0, rs.getString(6).indexOf("#!#"))));
740
                            } else {
741
                                reportItem.addIdentifier(new ItemIdentifier("DOI", rs.getString(6)));
742
                            }
743
                        }
744
                    }
745
                    fillWithZeros(postgresFormat.parse(lastDate), postgresFormat.parse(rs.getString(8)), reportItem);
746
                    Calendar endC = Calendar.getInstance();
747
                    endC.setTime(postgresFormat.parse(rs.getString(8)));
748
                    endC.set(Calendar.DATE, endC.getActualMaximum(Calendar.DATE));
749
                    if (reportItem != null) {
750
                        reportItem.addPerformance(new ItemPerformance(report_dateFormat.format(postgresFormat.parse(rs.getString(8))), report_dateFormat.format(endC.getTime()), rs.getString(10), rs.getString(11)));
751
                    }
752
                    endC.setTime(postgresFormat.parse(rs.getString(8)));
753
                    endC.add(Calendar.MONTH, 1);
754
                    lastDate = postgresFormat.format(endC.getTime());
755
                }
756
                if (reportItem != null) {
757
                    fillWithZeros(postgresFormat.parse(lastDate), endDateForZeros, reportItem);
758
                    reportItems.add(reportItem);
759
                }
760
            }
761

    
762
            /*
763
            jedis.put(redis_key, "persistent", "false");
764
            jedis.put(redis_key, "query", st.toString());
765
            jedis.put(redis_key, "result", toJson(reportItems));
766
            jedis.put(redis_key, "fetchMode", "3");
767
            */
768

    
769
        } catch (Exception e) {
770
            log.error("Batch Item Report failed: ", e);
771
        } finally {
772
            DbUtils.closeQuietly(rs);
773
            DbUtils.closeQuietly(st);
774
            DbUtils.closeQuietly(connection);
775
        }
776
    }
777

    
778
    private void fillWithZeros(Date from, Date to, ReportItem reportItem) {
779
        SimpleDateFormat report_dateFormat = new SimpleDateFormat("yyyy-MM-dd");
780

    
781
        Calendar fromCalendar = Calendar.getInstance();
782
        fromCalendar.setTime(from);
783

    
784
        Calendar toCalendar = Calendar.getInstance();
785
        toCalendar.setTime(to);
786
        while (from.before(to)) {
787
            Calendar temp_c = Calendar.getInstance();
788
            temp_c.setTime(from);
789
            temp_c.set(Calendar.DAY_OF_MONTH, temp_c.getActualMaximum(Calendar.DAY_OF_MONTH));
790
            Date temp_endDate = temp_c.getTime();
791

    
792
            reportItem.addPerformance(new ItemPerformance(report_dateFormat.format(from), report_dateFormat.format(temp_endDate), "0", "0"));
793
            fromCalendar.add(Calendar.MONTH, 1);
794
            from = fromCalendar.getTime();
795
        }
796
    }
797
}
(1-1/7)