← Back to branch summary

~ubuntu-branches/ubuntu/trusty/freeguide/trusty

« back to all changes in this revision

Viewing changes to src/freeguide/plugins/grabber/kulichki/GrabberKulichki.java

  • Committer: Bazaar Package Importer
  • Author(s): Shaun Jackman
  • Date: 2007-09-11 16:52:59 UTC
  • mfrom: (1.2.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070911165259-4r32oke21i1ezbmv
Tags: 0.10.5-1
http://bugs.debian.org/441762
* New upstream release.
* Update the watch file.
* Change Debian policy to version 3.7.2.2. No changes necessary.
* Add ant-optional to build dependencies. Closes: #441762.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/freeguide/plugins/grabber/kulichki/GrabberKulichki.java
3
3
import freeguide.common.lib.fgspecific.Application;
4
4
import freeguide.common.lib.fgspecific.data.TVChannel;
5
5
import freeguide.common.lib.fgspecific.data.TVChannelsSet;
6
 
import freeguide.common.lib.general.LanguageHelper;
7
6
import freeguide.common.lib.grabber.HttpBrowser;
8
7
 
9
8
import freeguide.common.plugininterfaces.BaseModule;
13
12
import freeguide.common.plugininterfaces.IProgress;
14
13
import freeguide.common.plugininterfaces.IStoragePipe;
15
14
 
 
15
import java.io.FileNotFoundException;
 
16
import java.io.IOException;
 
17
import java.io.InputStream;
 
18
 
 
19
import java.text.MessageFormat;
 
20
 
 
21
import java.util.ArrayList;
 
22
import java.util.Collection;
16
23
import java.util.Iterator;
 
24
import java.util.List;
17
25
import java.util.Map;
18
26
import java.util.Properties;
19
27
import java.util.TimeZone;
23
31
import javax.swing.JDialog;
24
32
 
25
33
/**
26
 
 * DOCUMENT ME!
 
34
 * Grabber for tv.kulichki.net.
27
35
 *
28
 
 * @author $author$
29
 
 * @version $Revision: 1360 $
 
36
 * @author Alex Buloichik
30
37
 */
31
38
public class GrabberKulichki extends BaseModule implements IModuleGrabber
32
39
{
 
40
    protected static final TimeZone TIME_ZONE_DEFAULT =
 
41
        TimeZone.getTimeZone( "Europe/Moscow" );
 
42
    protected static final String FILE_GROUPNAMES =
 
43
        "resources/plugins/grabber/kulichki/groupnames.properties";
 
44
    protected static final String FILE_TIMEZONES =
 
45
        "resources/plugins/grabber/kulichki/timezones.properties";
 
46
    protected static final String VALUE_ACCEPT_LANGUAGE = "ru";
 
47
    protected static final String VALUE_ACCEPT_CHARSET = "windows-1251";
 
48
    protected static final String URL_START = "http://tv.kulichki.net";
 
49
    protected static final String URL_PACKET =
 
50
        "http://tv.kulichki.net/cgi-bin/gpack.cgi";
 
51
    protected static final String URL_DATA =
 
52
        "http://tv.kulichki.net/andgon/cgi-bin/itv.cgi";
 
53
    protected static final String PARAM_WEEK = "week";
 
54
    protected static final String PARAM_PACKET = "pakets";
 
55
    protected static final String PARAM_CHANNEL = "chanel";
 
56
    protected static final String PARAM_DAY = "day";
 
57
    protected static final String CHANNEL_PREFIX_ID = "kulichki";
 
58
    protected static final String CHANNEL_PREFIX = "kulichki/";
 
59
    protected static final String[] DAYS_LIST = "1,2,3,4,5,6,7".split( "," );
33
60
    protected Properties TIME_ZONES;
34
 
    protected Map GROUP_NAMES;
35
 
    protected TimeZone TIME_ZONE_DEFAULT =
36
 
        TimeZone.getTimeZone( "Europe/Moscow" );
37
 
    protected KulichkiConfig config = new KulichkiConfig(  );
 
61
    protected Properties GROUP_NAMES;
 
62
    protected KulichkiConfig config = new KulichkiConfig( i18n );
38
63
 
39
64
    /**
40
65
     * DOCUMENT_ME!
71
96
    {
72
97
        final TVChannelsSet result = new TVChannelsSet(  );
73
98
 
74
 
        result.add( new TVChannelsSet.Channel( "kulichki", "All" ) );
 
99
        result.add( 
 
100
            new TVChannelsSet.Channel( 
 
101
                CHANNEL_PREFIX_ID, i18n.getString( "MainChannelName" ) ) );
75
102
 
76
103
        HttpBrowser browser = new HttpBrowser(  );
77
104
 
78
 
        browser.setHeader( "Accept-Language", "ru" );
 
105
        browser.setHeader( 
 
106
            HttpBrowser.HEADER_ACCEPT_LANGUAGE, VALUE_ACCEPT_LANGUAGE );
79
107
 
80
 
        browser.setHeader( "Accept-Charset", "windows-1251" );
 
108
        browser.setHeader( 
 
109
            HttpBrowser.HEADER_ACCEPT_CHARSET, VALUE_ACCEPT_CHARSET );
81
110
 
82
111
        HandlerPackets handlerPackets = new HandlerPackets(  );
83
112
 
84
113
        HandlerChannels handlerChanels = new HandlerChannels(  );
85
114
 
86
 
        browser.loadURL( "http://tv.kulichki.net" );
 
115
        browser.loadURL( URL_START );
87
116
 
88
117
        browser.parse( handlerPackets );
89
118
 
90
119
        String[] weeks = handlerPackets.getWeeks(  );
91
120
 
92
 
        String[] packetIDs = handlerPackets.getPacketIDs(  );
93
 
 
94
 
        Map request = new TreeMap(  );
95
 
 
96
 
        request.put( "week", weeks[0] );
97
 
 
98
 
        for( int j = 0; j < packetIDs.length; j++ )
 
121
        final Collection packetIDs = handlerPackets.getPacketIDs(  );
 
122
 
 
123
        final Map<String, String> request = new TreeMap<String, String>(  );
 
124
 
 
125
        request.put( PARAM_WEEK, weeks[0] );
 
126
 
 
127
        for( final Iterator itPa = packetIDs.iterator(  ); itPa.hasNext(  ); )
99
128
        {
 
129
            final String packetName = (String)itPa.next(  );
100
130
            result.add( 
101
131
                new TVChannelsSet.Channel( 
102
 
                    "kulichki/" + packetIDs[j],
103
 
                    (String)handlerPackets.packetList.get( packetIDs[j] ) ) );
104
 
 
105
 
            request.put( "pakets", packetIDs[j] );
106
 
 
107
 
            browser.loadURL( 
108
 
                "http://tv.kulichki.net/cgi-bin/gpack.cgi", request, true );
 
132
                    CHANNEL_PREFIX + packetName,
 
133
                    (String)handlerPackets.packetList.get( packetName ) ) );
 
134
 
 
135
            request.put( PARAM_PACKET, packetName );
 
136
 
 
137
            browser.loadURL( URL_PACKET, request, true );
109
138
 
110
139
            browser.parse( handlerChanels );
111
140
 
119
148
 
120
149
                result.add( 
121
150
                    new TVChannelsSet.Channel( 
122
 
                        "kulichki/" + packetIDs[j] + "/" + channelID,
 
151
                        CHANNEL_PREFIX + packetName + '/' + channelID,
123
152
                        (String)handlerChanels.channelList.get( key ) ) );
124
 
 
125
153
            }
126
154
        }
127
155
 
128
156
        return result;
129
 
 
130
157
    }
131
158
 
132
159
    /**
163
190
            Map.Entry entry = (Map.Entry)it.next(  );
164
191
            storage.addChannel( 
165
192
                new TVChannel( 
166
 
                    "kulichki/" + (String)entry.getKey(  ),
 
193
                    CHANNEL_PREFIX + (String)entry.getKey(  ),
167
194
                    (String)entry.getValue(  ) ) );
168
195
        }
169
196
 
170
197
        HttpBrowser browser = new HttpBrowser(  );
171
198
 
172
 
        browser.setHeader( "Accept-Language", "ru" );
 
199
        browser.setHeader( 
 
200
            HttpBrowser.HEADER_ACCEPT_LANGUAGE, VALUE_ACCEPT_LANGUAGE );
173
201
 
174
 
        browser.setHeader( "Accept-Charset", "windows-1251" );
 
202
        browser.setHeader( 
 
203
            HttpBrowser.HEADER_ACCEPT_CHARSET, VALUE_ACCEPT_CHARSET );
175
204
 
176
205
        HandlerPackets handlerPackets = new HandlerPackets(  );
177
206
 
178
207
        HandlerChannels handlerChanels = new HandlerChannels(  );
179
208
 
180
 
        HandlerProg handlerProg = new HandlerProg( storage, logger );
181
 
 
182
 
        logger.info( "Load initial page" );
183
 
 
184
 
        browser.loadURL( "http://tv.kulichki.net" );
 
209
        HandlerProg handlerProg = new HandlerProg( storage, logger, i18n );
 
210
 
 
211
        logger.info( i18n.getString( "Logging.LoadStartPage" ) );
 
212
 
 
213
        browser.loadURL( URL_START );
185
214
 
186
215
        browser.parse( handlerPackets );
187
216
 
188
 
        String[] weeks = handlerPackets.getWeeks(  );
189
 
 
190
 
        String[] packets = handlerPackets.getPacketIDs(  );
 
217
        final String[] weeks = handlerPackets.getWeeks(  );
 
218
 
 
219
        final List packetsList =
 
220
            new ArrayList( handlerPackets.getPacketIDs(  ) );
 
221
 
 
222
        for( final Iterator it = packetsList.iterator(  ); it.hasNext(  ); )
 
223
        {
 
224
            final String packetName = (String)it.next(  );
 
225
 
 
226
            if( 
 
227
                !config.channels.isSelected( CHANNEL_PREFIX + packetName )
 
228
                    && !config.channels.isChildSelected( 
 
229
                        CHANNEL_PREFIX + packetName ) )
 
230
            {
 
231
                it.remove(  );
 
232
            }
 
233
        }
 
234
 
 
235
        final String[] packets =
 
236
            (String[])packetsList.toArray( new String[packetsList.size(  )] );
191
237
 
192
238
        Map request = new TreeMap(  );
193
239
 
194
 
        Map requestChannels = new TreeMap(  );
195
 
 
196
 
        requestChannels.put( 
197
 
            "day", new String[] { "1", "2", "3", "4", "5", "6", "7" } );
 
240
        final Map<String, Object> requestChannels =
 
241
            new TreeMap<String, Object>(  );
 
242
 
 
243
        requestChannels.put( PARAM_DAY, DAYS_LIST );
 
244
 
 
245
        progress.setStepCount( weeks.length * packets.length );
 
246
        progress.setStepNumber( 0 );
198
247
 
199
248
        for( int i = 0; i < weeks.length; i++ )
200
249
        {
201
 
            request.put( "week", weeks[i] );
 
250
            request.put( PARAM_WEEK, weeks[i] );
202
251
 
203
 
            requestChannels.put( "week", weeks[i] );
 
252
            requestChannels.put( PARAM_WEEK, weeks[i] );
204
253
 
205
254
            for( int j = 0; j < packets.length; j++ )
206
255
            {
207
 
                if( 
208
 
                    !config.channels.isSelected( "kulichki/" + packets[j] )
209
 
                        && !config.channels.isChildSelected( 
210
 
                            "kulichki/" + packets[j] ) )
211
 
                {
212
 
                    continue;
213
 
                }
214
 
 
215
 
                request.put( "pakets", packets[j] );
 
256
                request.put( PARAM_PACKET, packets[j] );
216
257
 
217
258
                handlerProg.setChannelIDprefix( 
218
 
                    "kulichki/" + packets[j] + "/" );
 
259
                    CHANNEL_PREFIX + packets[j] + '/' );
219
260
 
220
261
                String tzName = TIME_ZONES.getProperty( packets[j] );
221
262
 
228
269
                else
229
270
                {
230
271
                    logger.warning( 
231
 
                        "Unknown timezone for packet '" + packets[j]
232
 
                        + "'. Will use Europe/Moscow timezone." );
 
272
                        MessageFormat.format( 
 
273
                            i18n.getString( "Logging.UnknownTimeZone" ),
 
274
                            packets[j] ) );
233
275
 
234
276
                    handlerProg.setTimeZone( TIME_ZONE_DEFAULT );
235
277
 
236
278
                }
237
279
 
238
280
                logger.info( 
239
 
                    "Load week [" + ( i + 1 ) + "/" + weeks.length
240
 
                    + "] packet [" + ( j + 1 ) + "/" + packets.length
241
 
                    + "]: channel list" );
 
281
                    MessageFormat.format( 
 
282
                        i18n.getString( "Logging.LoadList" ), i + 1,
 
283
                        weeks.length, j + 1, packets.length ) );
242
284
 
243
 
                browser.loadURL( 
244
 
                    "http://tv.kulichki.net/cgi-bin/gpack.cgi", request, true );
 
285
                browser.loadURL( URL_PACKET, request, true );
245
286
 
246
287
                browser.parse( handlerChanels );
247
288
 
248
289
                logger.info( 
249
 
                    "Load week [" + ( i + 1 ) + "/" + weeks.length
250
 
                    + "] packet [" + ( j + 1 ) + "/" + packets.length
251
 
                    + "]: channel data" );
 
290
                    MessageFormat.format( 
 
291
                        i18n.getString( "Logging.LoadData" ), i + 1,
 
292
                        weeks.length, j + 1, packets.length ) );
252
293
 
253
294
                for( 
254
295
                    Iterator it =
256
297
                        it.hasNext(  ); )
257
298
                {
258
299
                    String channelID =
259
 
                        "kulichki/" + packets[j] + "/"
 
300
                        CHANNEL_PREFIX + packets[j] + '/'
260
301
                        + getChannelIdByTag( (String)it.next(  ) );
261
302
 
262
303
                    if( !config.channels.isSelected( channelID ) )
266
307
                }
267
308
 
268
309
                requestChannels.put( 
269
 
                    "chanel", handlerChanels.channelList.keySet(  ) );
 
310
                    PARAM_CHANNEL, handlerChanels.channelList.keySet(  ) );
270
311
 
271
 
                browser.loadURL( 
272
 
                    "http://tv.kulichki.net/andgon/cgi-bin/itv.cgi",
273
 
                    requestChannels, true );
 
312
                browser.loadURL( URL_DATA, requestChannels, true );
274
313
 
275
314
                browser.parse( handlerProg );
276
315
                storage.finishBlock(  );
 
316
 
 
317
                progress.setStepNumber( ( i * packets.length ) + j + 1 );
277
318
            }
278
319
        }
279
320
    }
309
350
    {
310
351
        TIME_ZONES = new Properties(  );
311
352
 
 
353
        final InputStream in =
 
354
            GrabberKulichki.class.getClassLoader(  )
 
355
                                 .getResourceAsStream( FILE_TIMEZONES );
 
356
 
312
357
        try
313
358
        {
314
 
            TIME_ZONES.load( 
315
 
                LanguageHelper.getUncachedStream( 
316
 
                    "resources/plugins/grabber/kulichki/timezones.properties" ) );
 
359
            if( in == null )
 
360
            {
 
361
                throw new FileNotFoundException(  );
 
362
            }
317
363
 
 
364
            TIME_ZONES.load( in );
 
365
            in.close(  );
318
366
        }
319
 
        catch( Exception ex )
 
367
        catch( IOException ex )
320
368
        {
321
369
            Application.getInstance(  ).getLogger(  )
322
370
                       .log( 
327
375
 
328
376
    protected void loadGroupNames(  )
329
377
    {
330
 
        GROUP_NAMES = new TreeMap(  );
 
378
        GROUP_NAMES = new Properties(  );
 
379
 
 
380
        final InputStream in =
 
381
            GrabberKulichki.class.getClassLoader(  )
 
382
                                 .getResourceAsStream( FILE_GROUPNAMES );
331
383
 
332
384
        try
333
385
        {
334
 
            LanguageHelper.loadProperties( 
335
 
                "resources/plugins/grabber/kulichki/groupnames.properties",
336
 
                GROUP_NAMES );
 
386
            if( in == null )
 
387
            {
 
388
                throw new FileNotFoundException(  );
 
389
            }
 
390
 
 
391
            GROUP_NAMES.load( in );
 
392
            in.close(  );
337
393
        }
338
 
        catch( Exception ex )
 
394
        catch( IOException ex )
339
395
        {
340
396
            Application.getInstance(  ).getLogger(  )
341
397
                       .log(