src/be/nikiroo/fanfix/library/BasicLibrary.java

   1 package be.nikiroo.fanfix.library;
   2
   3 import java.io.File;
   4 import java.io.IOException;
   5 import java.net.URL;
   6 import java.net.UnknownHostException;
   7 import java.util.ArrayList;
   8 import java.util.Collections;
   9 import java.util.List;
  10
  11 import be.nikiroo.fanfix.Instance;
  12 import be.nikiroo.fanfix.data.MetaData;
  13 import be.nikiroo.fanfix.data.Story;
  14 import be.nikiroo.fanfix.output.BasicOutput;
  15 import be.nikiroo.fanfix.output.BasicOutput.OutputType;
  16 import be.nikiroo.fanfix.supported.BasicSupport;
  17 import be.nikiroo.fanfix.supported.SupportType;
  18 import be.nikiroo.utils.Image;
  19 import be.nikiroo.utils.Progress;
  20
  21 /**
  22  * Manage a library of Stories: import, export, list, modify.
  23  * <p>
  24  * Each {@link Story} object will be associated with a (local to the library)
  25  * unique ID, the LUID, which will be used to identify the {@link Story}.
  26  * <p>
  27  * Most of the {@link BasicLibrary} functions work on a partial (cover
  28  * <b>MAY</b> not be included) {@link MetaData} object.
  29  *
  30  * @author niki
  31  */
  32 abstract public class BasicLibrary {
  33         /**
  34          * A {@link BasicLibrary} status.
  35          *
  36          * @author niki
  37          */
  38         public enum Status {
  39                 /** The library is ready. */
  40                 READY,
  41                 /** The library is invalid (not correctly set up). */
  42                 INVALID,
  43                 /** You are not allowed to access this library. */
  44                 UNAUTORIZED,
  45                 /** The library is currently out of commission. */
  46                 UNAVAILABLE,
  47         }
  48
  49         /**
  50          * Return a name for this library (the UI may display this).
  51          * <p>
  52          * Must not be NULL.
  53          *
  54          * @return the name, or an empty {@link String} if none
  55          */
  56         public String getLibraryName() {
  57                 return "";
  58         }
  59
  60         /**
  61          * The library status.
  62          *
  63          * @return the current status
  64          */
  65         public Status getStatus() {
  66                 return Status.READY;
  67         }
  68
  69         /**
  70          * Retrieve the main {@link File} corresponding to the given {@link Story},
  71          * which can be passed to an external reader or instance.
  72          * <p>
  73          * Do <b>NOT</b> alter this file.
  74          *
  75          * @param luid
  76          *            the Library UID of the story
  77          * @param pg
  78          *            the optional {@link Progress}
  79          *
  80          * @return the corresponding {@link Story}
  81          */
  82         public abstract File getFile(String luid, Progress pg);
  83
  84         /**
  85          * Return the cover image associated to this story.
  86          *
  87          * @param luid
  88          *            the Library UID of the story
  89          *
  90          * @return the cover image
  91          */
  92         public abstract Image getCover(String luid);
  93
  94         /**
  95          * Return the cover image associated to this source.
  96          * <p>
  97          * By default, return the cover of the first story with this source.
  98          *
  99          * @param source
 100          *            the source
 101          *
 102          * @return the cover image or NULL
 103          */
 104         public Image getSourceCover(String source) {
 105                 List<MetaData> metas = getListBySource(source);
 106                 if (metas.size() > 0) {
 107                         return getCover(metas.get(0).getLuid());
 108                 }
 109
 110                 return null;
 111         }
 112
 113         /**
 114          * Fix the source cover to the given story cover.
 115          *
 116          * @param source
 117          *            the source to change
 118          * @param luid
 119          *            the story LUID
 120          */
 121         public abstract void setSourceCover(String source, String luid);
 122
 123         /**
 124          * Return the list of stories (represented by their {@link MetaData}, which
 125          * <b>MAY</b> not have the cover included).
 126          *
 127          * @param pg
 128          *            the optional {@link Progress}
 129          *
 130          * @return the list (can be empty but not NULL)
 131          */
 132         protected abstract List<MetaData> getMetas(Progress pg);
 133
 134         /**
 135          * Invalidate the {@link Story} cache (when the content should be re-read
 136          * because it was changed).
 137          */
 138         protected void deleteInfo() {
 139                 deleteInfo(null);
 140         }
 141
 142         /**
 143          * Invalidate the {@link Story} cache (when the content is removed).
 144          * <p>
 145          * All the cache can be deleted if NULL is passed as meta.
 146          *
 147          * @param luid
 148          *            the LUID of the {@link Story} to clear from the cache, or NULL
 149          *            for all stories
 150          */
 151         protected abstract void deleteInfo(String luid);
 152
 153         /**
 154          * Invalidate the {@link Story} cache (when the content has changed, but we
 155          * already have it) with the new given meta.
 156          *
 157          * @param meta
 158          *            the {@link Story} to clear from the cache
 159          */
 160         protected abstract void updateInfo(MetaData meta);
 161
 162         /**
 163          * Return the next LUID that can be used.
 164          *
 165          * @return the next luid
 166          */
 167         protected abstract int getNextId();
 168
 169         /**
 170          * Delete the target {@link Story}.
 171          *
 172          * @param luid
 173          *            the LUID of the {@link Story}
 174          *
 175          * @throws IOException
 176          *             in case of I/O error or if the {@link Story} wa not found
 177          */
 178         protected abstract void doDelete(String luid) throws IOException;
 179
 180         /**
 181          * Actually save the story to the back-end.
 182          *
 183          * @param story
 184          *            the {@link Story} to save
 185          * @param pg
 186          *            the optional {@link Progress}
 187          *
 188          * @return the saved {@link Story} (which may have changed, especially
 189          *         regarding the {@link MetaData})
 190          *
 191          * @throws IOException
 192          *             in case of I/O error
 193          */
 194         protected abstract Story doSave(Story story, Progress pg)
 195                         throws IOException;
 196
 197         /**
 198          * Refresh the {@link BasicLibrary}, that is, make sure all metas are
 199          * loaded.
 200          *
 201          * @param pg
 202          *            the optional progress reporter
 203          */
 204         public void refresh(Progress pg) {
 205                 getMetas(pg);
 206         }
 207
 208         /**
 209          * List all the known types (sources) of stories.
 210          *
 211          * @return the sources
 212          */
 213         public synchronized List<String> getSources() {
 214                 List<String> list = new ArrayList<String>();
 215                 for (MetaData meta : getMetas(null)) {
 216                         String storySource = meta.getSource();
 217                         if (!list.contains(storySource)) {
 218                                 list.add(storySource);
 219                         }
 220                 }
 221
 222                 Collections.sort(list);
 223                 return list;
 224         }
 225
 226         /**
 227          * List all the known authors of stories.
 228          *
 229          * @return the authors
 230          */
 231         public synchronized List<String> getAuthors() {
 232                 List<String> list = new ArrayList<String>();
 233                 for (MetaData meta : getMetas(null)) {
 234                         String storyAuthor = meta.getAuthor();
 235                         if (!list.contains(storyAuthor)) {
 236                                 list.add(storyAuthor);
 237                         }
 238                 }
 239
 240                 Collections.sort(list);
 241                 return list;
 242         }
 243
 244         /**
 245          * List all the stories in the {@link BasicLibrary}.
 246          * <p>
 247          * Cover images not included.
 248          *
 249          * @return the stories
 250          */
 251         public synchronized List<MetaData> getList() {
 252                 return getMetas(null);
 253         }
 254
 255         /**
 256          * List all the stories of the given source type in the {@link BasicLibrary}
 257          * , or all the stories if NULL is passed as a type.
 258          * <p>
 259          * Cover images not included.
 260          *
 261          * @param type
 262          *            the type of story to retrieve, or NULL for all
 263          *
 264          * @return the stories
 265          */
 266         public synchronized List<MetaData> getListBySource(String type) {
 267                 List<MetaData> list = new ArrayList<MetaData>();
 268                 for (MetaData meta : getMetas(null)) {
 269                         String storyType = meta.getSource();
 270                         if (type == null || type.equalsIgnoreCase(storyType)) {
 271                                 list.add(meta);
 272                         }
 273                 }
 274
 275                 Collections.sort(list);
 276                 return list;
 277         }
 278
 279         /**
 280          * List all the stories of the given author in the {@link BasicLibrary}, or
 281          * all the stories if NULL is passed as an author.
 282          * <p>
 283          * Cover images not included.
 284          *
 285          * @param author
 286          *            the author of the stories to retrieve, or NULL for all
 287          *
 288          * @return the stories
 289          */
 290         public synchronized List<MetaData> getListByAuthor(String author) {
 291                 List<MetaData> list = new ArrayList<MetaData>();
 292                 for (MetaData meta : getMetas(null)) {
 293                         String storyAuthor = meta.getAuthor();
 294                         if (author == null || author.equalsIgnoreCase(storyAuthor)) {
 295                                 list.add(meta);
 296                         }
 297                 }
 298
 299                 Collections.sort(list);
 300                 return list;
 301         }
 302
 303         /**
 304          * Retrieve a {@link MetaData} corresponding to the given {@link Story},
 305          * cover image <b>MAY</b> not be included.
 306          *
 307          * @param luid
 308          *            the Library UID of the story
 309          *
 310          * @return the corresponding {@link Story}
 311          */
 312         public synchronized MetaData getInfo(String luid) {
 313                 if (luid != null) {
 314                         for (MetaData meta : getMetas(null)) {
 315                                 if (luid.equals(meta.getLuid())) {
 316                                         return meta;
 317                                 }
 318                         }
 319                 }
 320
 321                 return null;
 322         }
 323
 324         /**
 325          * Retrieve a specific {@link Story}.
 326          *
 327          * @param luid
 328          *            the Library UID of the story
 329          * @param pg
 330          *            the optional progress reporter
 331          *
 332          * @return the corresponding {@link Story} or NULL if not found
 333          */
 334         public synchronized Story getStory(String luid, Progress pg) {
 335                 if (pg == null) {
 336                         pg = new Progress();
 337                 }
 338
 339                 Progress pgGet = new Progress();
 340                 Progress pgProcess = new Progress();
 341
 342                 pg.setMinMax(0, 2);
 343                 pg.addProgress(pgGet, 1);
 344                 pg.addProgress(pgProcess, 1);
 345
 346                 Story story = null;
 347                 for (MetaData meta : getMetas(null)) {
 348                         if (meta.getLuid().equals(luid)) {
 349                                 File file = getFile(luid, pgGet);
 350                                 pgGet.done();
 351                                 try {
 352                                         SupportType type = SupportType.valueOfAllOkUC(meta
 353                                                         .getType());
 354                                         URL url = file.toURI().toURL();
 355                                         if (type != null) {
 356                                                 story = BasicSupport.getSupport(type, url) //
 357                                                                 .process(pgProcess);
 358                                                 System.out.println("orig meta: "+meta);
 359                                                 System.out.println("story retrieved: "+story);
 360                                                 // Because we do not want to clear the meta cache:
 361                                                 meta.setCover(story.getMeta().getCover());
 362                                                 story.setMeta(meta);
 363                                                 //
 364                                         } else {
 365                                                 throw new IOException("Unknown type: " + meta.getType());
 366                                         }
 367                                 } catch (IOException e) {
 368                                         // We should not have not-supported files in the
 369                                         // library
 370                                         Instance.getTraceHandler().error(
 371                                                         new IOException("Cannot load file from library: "
 372                                                                         + file, e));
 373                                 } finally {
 374                                         pgProcess.done();
 375                                         pg.done();
 376                                 }
 377
 378                                 break;
 379                         }
 380                 }
 381
 382                 return story;
 383         }
 384
 385         /**
 386          * Import the {@link Story} at the given {@link URL} into the
 387          * {@link BasicLibrary}.
 388          *
 389          * @param url
 390          *            the {@link URL} to import
 391          * @param pg
 392          *            the optional progress reporter
 393          *
 394          * @return the imported {@link Story}
 395          *
 396          * @throws UnknownHostException
 397          *             if the host is not supported
 398          * @throws IOException
 399          *             in case of I/O error
 400          */
 401         public Story imprt(URL url, Progress pg) throws IOException {
 402                 BasicSupport support = BasicSupport.getSupport(url);
 403                 if (support == null) {
 404                         throw new UnknownHostException("" + url);
 405                 }
 406
 407                 return save(support.process(pg), null);
 408         }
 409
 410         /**
 411          * Import the story from one library to another, and keep the same LUID.
 412          *
 413          * @param other
 414          *            the other library to import from
 415          * @param luid
 416          *            the Library UID
 417          * @param pg
 418          *            the optional progress reporter
 419          *
 420          * @throws IOException
 421          *             in case of I/O error
 422          */
 423         public void imprt(BasicLibrary other, String luid, Progress pg)
 424                         throws IOException {
 425                 Progress pgGetStory = new Progress();
 426                 Progress pgSave = new Progress();
 427                 if (pg == null) {
 428                         pg = new Progress();
 429                 }
 430
 431                 pg.setMinMax(0, 2);
 432                 pg.addProgress(pgGetStory, 1);
 433                 pg.addProgress(pgSave, 1);
 434
 435                 Story story = other.getStory(luid, pgGetStory);
 436                 if (story != null) {
 437                         story = this.save(story, luid, pgSave);
 438                         pg.done();
 439                 } else {
 440                         pg.done();
 441                         throw new IOException("Cannot find story in Library: " + luid);
 442                 }
 443         }
 444
 445         /**
 446          * Export the {@link Story} to the given target in the given format.
 447          *
 448          * @param luid
 449          *            the {@link Story} ID
 450          * @param type
 451          *            the {@link OutputType} to transform it to
 452          * @param target
 453          *            the target to save to
 454          * @param pg
 455          *            the optional progress reporter
 456          *
 457          * @return the saved resource (the main saved {@link File})
 458          *
 459          * @throws IOException
 460          *             in case of I/O error
 461          */
 462         public File export(String luid, OutputType type, String target, Progress pg)
 463                         throws IOException {
 464                 Progress pgGetStory = new Progress();
 465                 Progress pgOut = new Progress();
 466                 if (pg != null) {
 467                         pg.setMax(2);
 468                         pg.addProgress(pgGetStory, 1);
 469                         pg.addProgress(pgOut, 1);
 470                 }
 471
 472                 BasicOutput out = BasicOutput.getOutput(type, false, false);
 473                 if (out == null) {
 474                         throw new IOException("Output type not supported: " + type);
 475                 }
 476
 477                 Story story = getStory(luid, pgGetStory);
 478                 if (story == null) {
 479                         throw new IOException("Cannot find story to export: " + luid);
 480                 }
 481
 482                 return out.process(story, target, pgOut);
 483         }
 484
 485         /**
 486          * Save a {@link Story} to the {@link BasicLibrary}.
 487          *
 488          * @param story
 489          *            the {@link Story} to save
 490          * @param pg
 491          *            the optional progress reporter
 492          *
 493          * @return the same {@link Story}, whose LUID may have changed
 494          *
 495          * @throws IOException
 496          *             in case of I/O error
 497          */
 498         public Story save(Story story, Progress pg) throws IOException {
 499                 return save(story, null, pg);
 500         }
 501
 502         /**
 503          * Save a {@link Story} to the {@link BasicLibrary} -- the LUID <b>must</b>
 504          * be correct, or NULL to get the next free one.
 505          * <p>
 506          * Will override any previous {@link Story} with the same LUID.
 507          *
 508          * @param story
 509          *            the {@link Story} to save
 510          * @param luid
 511          *            the <b>correct</b> LUID or NULL to get the next free one
 512          * @param pg
 513          *            the optional progress reporter
 514          *
 515          * @return the same {@link Story}, whose LUID may have changed
 516          *
 517          * @throws IOException
 518          *             in case of I/O error
 519          */
 520         public synchronized Story save(Story story, String luid, Progress pg)
 521                         throws IOException {
 522
 523                 // Do not change the original metadata, but change the original story
 524                 MetaData meta = story.getMeta().clone();
 525                 story.setMeta(meta);
 526
 527                 if (luid == null || luid.isEmpty()) {
 528                         meta.setLuid(String.format("%03d", getNextId()));
 529                 } else {
 530                         meta.setLuid(luid);
 531                 }
 532
 533                 if (luid != null && getInfo(luid) != null) {
 534                         delete(luid);
 535                 }
 536
 537                 story = doSave(story, pg);
 538
 539                 updateInfo(story.getMeta());
 540
 541                 return story;
 542         }
 543
 544         /**
 545          * Delete the given {@link Story} from this {@link BasicLibrary}.
 546          *
 547          * @param luid
 548          *            the LUID of the target {@link Story}
 549          *
 550          * @throws IOException
 551          *             in case of I/O error
 552          */
 553         public synchronized void delete(String luid) throws IOException {
 554                 doDelete(luid);
 555                 deleteInfo(luid);
 556         }
 557
 558         /**
 559          * Change the type (source) of the given {@link Story}.
 560          *
 561          * @param luid
 562          *            the {@link Story} LUID
 563          * @param newSource
 564          *            the new source
 565          * @param pg
 566          *            the optional progress reporter
 567          *
 568          * @throws IOException
 569          *             in case of I/O error or if the {@link Story} was not found
 570          */
 571         public synchronized void changeSource(String luid, String newSource,
 572                         Progress pg) throws IOException {
 573                 MetaData meta = getInfo(luid);
 574                 if (meta == null) {
 575                         throw new IOException("Story not found: " + luid);
 576                 }
 577
 578                 meta.setSource(newSource);
 579                 saveMeta(meta, pg);
 580         }
 581
 582         /**
 583          * Save back the current state of the {@link MetaData} (LUID <b>MUST NOT</b>
 584          * change) for this {@link Story}.
 585          * <p>
 586          * By default, delete the old {@link Story} then recreate a new
 587          * {@link Story}.
 588          * <p>
 589          * Note that this behaviour can lead to data loss.
 590          *
 591          * @param meta
 592          *            the new {@link MetaData} (LUID <b>MUST NOT</b> change)
 593          * @param pg
 594          *            the optional {@link Progress}
 595          *
 596          * @throws IOException
 597          *             in case of I/O error or if the {@link Story} was not found
 598          */
 599         protected synchronized void saveMeta(MetaData meta, Progress pg)
 600                         throws IOException {
 601                 if (pg == null) {
 602                         pg = new Progress();
 603                 }
 604
 605                 Progress pgGet = new Progress();
 606                 Progress pgSet = new Progress();
 607                 pg.addProgress(pgGet, 50);
 608                 pg.addProgress(pgSet, 50);
 609
 610                 Story story = getStory(meta.getLuid(), pgGet);
 611                 if (story == null) {
 612                         throw new IOException("Story not found: " + meta.getLuid());
 613                 }
 614
 615                 delete(meta.getLuid());
 616
 617                 story.setMeta(meta);
 618                 save(story, meta.getLuid(), pgSet);
 619
 620                 pg.done();
 621         }
 622 }