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 import java.util.Map;
  11 import java.util.TreeMap;
  12
  13 import be.nikiroo.fanfix.Instance;
  14 import be.nikiroo.fanfix.data.MetaData;
  15 import be.nikiroo.fanfix.data.Story;
  16 import be.nikiroo.fanfix.output.BasicOutput;
  17 import be.nikiroo.fanfix.output.BasicOutput.OutputType;
  18 import be.nikiroo.fanfix.supported.BasicSupport;
  19 import be.nikiroo.fanfix.supported.SupportType;
  20 import be.nikiroo.utils.Image;
  21 import be.nikiroo.utils.Progress;
  22 import be.nikiroo.utils.StringUtils;
  23
  24 /**
  25  * Manage a library of Stories: import, export, list, modify.
  26  * <p>
  27  * Each {@link Story} object will be associated with a (local to the library)
  28  * unique ID, the LUID, which will be used to identify the {@link Story}.
  29  * <p>
  30  * Most of the {@link BasicLibrary} functions work on a partial (cover
  31  * <b>MAY</b> not be included) {@link MetaData} object.
  32  *
  33  * @author niki
  34  */
  35 abstract public class BasicLibrary {
  36         /**
  37          * A {@link BasicLibrary} status.
  38          *
  39          * @author niki
  40          */
  41         public enum Status {
  42                 /** The library is ready and r/w. */
  43                 READ_WRITE,
  44                 /** The library is ready, but read-only. */
  45                 READ_ONLY,
  46                 /** The library is invalid (not correctly set up). */
  47                 INVALID,
  48                 /** You are not allowed to access this library. */
  49                 UNAUTHORIZED,
  50                 /** The library is currently out of commission. */
  51                 UNAVAILABLE;
  52
  53                 /**
  54                  * The library is available (you can query it).
  55                  * <p>
  56                  * It does <b>not</b> specify if it is read-only or not.
  57                  *
  58                  * @return TRUE if it is
  59                  */
  60                 public boolean isReady() {
  61                         return (this == READ_WRITE || this == READ_ONLY);
  62                 }
  63
  64                 /**
  65                  * This library can be modified (= you are allowed to modify it).
  66                  *
  67                  * @return TRUE if it is
  68                  */
  69                 public boolean isWritable() {
  70                         return (this == READ_WRITE);
  71                 }
  72         }
  73
  74         /**
  75          * Return a name for this library (the UI may display this).
  76          * <p>
  77          * Must not be NULL.
  78          *
  79          * @return the name, or an empty {@link String} if none
  80          */
  81         public String getLibraryName() {
  82                 return "";
  83         }
  84
  85         /**
  86          * The library status.
  87          *
  88          * @return the current status
  89          */
  90         public Status getStatus() {
  91                 return Status.READ_WRITE;
  92         }
  93
  94         /**
  95          * Retrieve the main {@link File} corresponding to the given {@link Story},
  96          * which can be passed to an external reader or instance.
  97          * <p>
  98          * Do <b>NOT</b> alter this file.
  99          *
 100          * @param luid
 101          *            the Library UID of the story, can be NULL
 102          * @param pg
 103          *            the optional {@link Progress}
 104          *
 105          * @return the corresponding {@link Story}
 106          *
 107          * @throws IOException
 108          *             in case of IOException
 109          */
 110         public abstract File getFile(String luid, Progress pg) throws IOException;
 111
 112         /**
 113          * Return the cover image associated to this story.
 114          *
 115          * @param luid
 116          *            the Library UID of the story
 117          *
 118          * @return the cover image
 119          *
 120          * @throws IOException
 121          *             in case of IOException
 122          */
 123         public abstract Image getCover(String luid) throws IOException;
 124
 125         // TODO: ensure it is the main used interface
 126         public MetaResultList getList(Progress pg) throws IOException {
 127                 return new MetaResultList(getMetas(pg));
 128         }
 129
 130         // TODO: make something for (normal and custom) not-story covers
 131
 132         /**
 133          * Return the cover image associated to this source.
 134          * <p>
 135          * By default, return the custom cover if any, and if not, return the cover
 136          * of the first story with this source.
 137          *
 138          * @param source
 139          *            the source
 140          *
 141          * @return the cover image or NULL
 142          *
 143          * @throws IOException
 144          *             in case of IOException
 145          */
 146         public Image getSourceCover(String source) throws IOException {
 147                 Image custom = getCustomSourceCover(source);
 148                 if (custom != null) {
 149                         return custom;
 150                 }
 151
 152                 List<MetaData> metas = getList().filter(source, null, null);
 153                 if (metas.size() > 0) {
 154                         return getCover(metas.get(0).getLuid());
 155                 }
 156
 157                 return null;
 158         }
 159
 160         /**
 161          * Return the cover image associated to this author.
 162          * <p>
 163          * By default, return the custom cover if any, and if not, return the cover
 164          * of the first story with this author.
 165          *
 166          * @param author
 167          *            the author
 168          *
 169          * @return the cover image or NULL
 170          *
 171          * @throws IOException
 172          *             in case of IOException
 173          */
 174         public Image getAuthorCover(String author) throws IOException {
 175                 Image custom = getCustomAuthorCover(author);
 176                 if (custom != null) {
 177                         return custom;
 178                 }
 179
 180                 List<MetaData> metas = getList().filter(null, author, null);
 181                 if (metas.size() > 0) {
 182                         return getCover(metas.get(0).getLuid());
 183                 }
 184
 185                 return null;
 186         }
 187
 188         /**
 189          * Return the custom cover image associated to this source.
 190          * <p>
 191          * By default, return NULL.
 192          *
 193          * @param source
 194          *            the source to look for
 195          *
 196          * @return the custom cover or NULL if none
 197          *
 198          * @throws IOException
 199          *             in case of IOException
 200          */
 201         @SuppressWarnings("unused")
 202         public Image getCustomSourceCover(String source) throws IOException {
 203                 return null;
 204         }
 205
 206         /**
 207          * Return the custom cover image associated to this author.
 208          * <p>
 209          * By default, return NULL.
 210          *
 211          * @param author
 212          *            the author to look for
 213          *
 214          * @return the custom cover or NULL if none
 215          *
 216          * @throws IOException
 217          *             in case of IOException
 218          */
 219         @SuppressWarnings("unused")
 220         public Image getCustomAuthorCover(String author) throws IOException {
 221                 return null;
 222         }
 223
 224         /**
 225          * Set the source cover to the given story cover.
 226          *
 227          * @param source
 228          *            the source to change
 229          * @param luid
 230          *            the story LUID
 231          *
 232          * @throws IOException
 233          *             in case of IOException
 234          */
 235         public abstract void setSourceCover(String source, String luid)
 236                         throws IOException;
 237
 238         /**
 239          * Set the author cover to the given story cover.
 240          *
 241          * @param author
 242          *            the author to change
 243          * @param luid
 244          *            the story LUID
 245          *
 246          * @throws IOException
 247          *             in case of IOException
 248          */
 249         public abstract void setAuthorCover(String author, String luid)
 250                         throws IOException;
 251
 252         /**
 253          * Return the list of stories (represented by their {@link MetaData}, which
 254          * <b>MAY</b> not have the cover included).
 255          * <p>
 256          * The returned list <b>MUST</b> be a copy, not the original one.
 257          *
 258          * @param pg
 259          *            the optional {@link Progress}
 260          *
 261          * @return the list (can be empty but not NULL)
 262          *
 263          * @throws IOException
 264          *             in case of IOException
 265          */
 266         protected abstract List<MetaData> getMetas(Progress pg) throws IOException;
 267
 268         /**
 269          * Invalidate the {@link Story} cache (when the content should be re-read
 270          * because it was changed).
 271          */
 272         protected void invalidateInfo() {
 273                 invalidateInfo(null);
 274         }
 275
 276         /**
 277          * Invalidate the {@link Story} cache (when the content is removed).
 278          * <p>
 279          * All the cache can be deleted if NULL is passed as meta.
 280          *
 281          * @param luid
 282          *            the LUID of the {@link Story} to clear from the cache, or NULL
 283          *            for all stories
 284          */
 285         protected abstract void invalidateInfo(String luid);
 286
 287         /**
 288          * Invalidate the {@link Story} cache (when the content has changed, but we
 289          * already have it) with the new given meta.
 290          *
 291          * @param meta
 292          *            the {@link Story} to clear from the cache
 293          *
 294          * @throws IOException
 295          *             in case of IOException
 296          */
 297         protected abstract void updateInfo(MetaData meta) throws IOException;
 298
 299         /**
 300          * Return the next LUID that can be used.
 301          *
 302          * @return the next luid
 303          */
 304         protected abstract int getNextId();
 305
 306         /**
 307          * Delete the target {@link Story}.
 308          *
 309          * @param luid
 310          *            the LUID of the {@link Story}
 311          *
 312          * @throws IOException
 313          *             in case of I/O error or if the {@link Story} wa not found
 314          */
 315         protected abstract void doDelete(String luid) throws IOException;
 316
 317         /**
 318          * Actually save the story to the back-end.
 319          *
 320          * @param story
 321          *            the {@link Story} to save
 322          * @param pg
 323          *            the optional {@link Progress}
 324          *
 325          * @return the saved {@link Story} (which may have changed, especially
 326          *         regarding the {@link MetaData})
 327          *
 328          * @throws IOException
 329          *             in case of I/O error
 330          */
 331         protected abstract Story doSave(Story story, Progress pg)
 332                         throws IOException;
 333
 334         /**
 335          * Refresh the {@link BasicLibrary}, that is, make sure all metas are
 336          * loaded.
 337          *
 338          * @param pg
 339          *            the optional progress reporter
 340          */
 341         public void refresh(Progress pg) {
 342                 try {
 343                         getMetas(pg);
 344                 } catch (IOException e) {
 345                         // We will let it fail later
 346                 }
 347         }
 348
 349         /**
 350          * Check if the {@link Story} denoted by this Library UID is present in the
 351          * cache (if we have no cache, we default to </tt>true</tt>).
 352          *
 353          * @param luid
 354          *            the Library UID
 355          *
 356          * @return TRUE if it is
 357          */
 358         public boolean isCached(@SuppressWarnings("unused") String luid) {
 359                 // By default, everything is cached
 360                 return true;
 361         }
 362
 363         /**
 364          * Clear the {@link Story} from the cache, if needed.
 365          * <p>
 366          * The next time we try to retrieve the {@link Story}, it may be required to
 367          * cache it again.
 368          *
 369          * @param luid
 370          *            the story to clear
 371          *
 372          * @throws IOException
 373          *             in case of I/O error
 374          */
 375         @SuppressWarnings("unused")
 376         public void clearFromCache(String luid) throws IOException {
 377                 // By default, this is a noop.
 378         }
 379
 380         /**
 381          * @deprecated please use {@link BasicLibrary#getList()} and
 382          *             {@link MetaResultList#getSources()} instead.
 383          */
 384         @Deprecated
 385         public List<String> getSources() throws IOException {
 386                 return getList().getSources();
 387         }
 388
 389         /**
 390          * @deprecated please use {@link BasicLibrary#getList()} and
 391          *             {@link MetaResultList#getSourcesGrouped()} instead.
 392          */
 393         @Deprecated
 394         public Map<String, List<String>> getSourcesGrouped() throws IOException {
 395                 return getList().getSourcesGrouped();
 396         }
 397
 398         /**
 399          * @deprecated please use {@link BasicLibrary#getList()} and
 400          *             {@link MetaResultList#getAuthors()} instead.
 401          */
 402         @Deprecated
 403         public List<String> getAuthors() throws IOException {
 404                 return getList().getAuthors();
 405         }
 406
 407         /**
 408          * @deprecated please use {@link BasicLibrary#getList()} and
 409          *             {@link MetaResultList#getAuthorsGrouped()} instead.
 410          */
 411         public Map<String, List<String>> getAuthorsGrouped() throws IOException {
 412                 return getList().getAuthorsGrouped();
 413         }
 414
 415         /**
 416          * List all the stories in the {@link BasicLibrary}.
 417          * <p>
 418          * Cover images <b>MAYBE</b> not included.
 419          *
 420          * @return the stories
 421          *
 422          * @throws IOException
 423          *             in case of IOException
 424          */
 425         public MetaResultList getList() throws IOException {
 426                 return getList(null);
 427         }
 428
 429         /**
 430          * Retrieve a {@link MetaData} corresponding to the given {@link Story},
 431          * cover image <b>MAY</b> not be included.
 432          *
 433          * @param luid
 434          *            the Library UID of the story, can be NULL
 435          *
 436          * @return the corresponding {@link Story} or NULL if not found
 437          *
 438          * @throws IOException
 439          *             in case of IOException
 440          */
 441         public MetaData getInfo(String luid) throws IOException {
 442                 if (luid != null) {
 443                         for (MetaData meta : getMetas(null)) {
 444                                 if (luid.equals(meta.getLuid())) {
 445                                         return meta;
 446                                 }
 447                         }
 448                 }
 449
 450                 return null;
 451         }
 452
 453         /**
 454          * Retrieve a specific {@link Story}.
 455          *
 456          * @param luid
 457          *            the Library UID of the story
 458          * @param pg
 459          *            the optional progress reporter
 460          *
 461          * @return the corresponding {@link Story} or NULL if not found
 462          *
 463          * @throws IOException
 464          *             in case of IOException
 465          */
 466         public Story getStory(String luid, Progress pg) throws IOException {
 467                 Progress pgMetas = new Progress();
 468                 Progress pgStory = new Progress();
 469                 if (pg != null) {
 470                         pg.setMinMax(0, 100);
 471                         pg.addProgress(pgMetas, 10);
 472                         pg.addProgress(pgStory, 90);
 473                 }
 474
 475                 MetaData meta = null;
 476                 for (MetaData oneMeta : getMetas(pgMetas)) {
 477                         if (oneMeta.getLuid().equals(luid)) {
 478                                 meta = oneMeta;
 479                                 break;
 480                         }
 481                 }
 482
 483                 pgMetas.done();
 484
 485                 Story story = getStory(luid, meta, pgStory);
 486                 pgStory.done();
 487
 488                 return story;
 489         }
 490
 491         /**
 492          * Retrieve a specific {@link Story}.
 493          *
 494          * @param luid
 495          *            the LUID of the story
 496          * @param meta
 497          *            the meta of the story
 498          * @param pg
 499          *            the optional progress reporter
 500          *
 501          * @return the corresponding {@link Story} or NULL if not found
 502          *
 503          * @throws IOException
 504          *             in case of IOException
 505          */
 506         public synchronized Story getStory(String luid, MetaData meta, Progress pg)
 507                         throws IOException {
 508
 509                 if (pg == null) {
 510                         pg = new Progress();
 511                 }
 512
 513                 Progress pgGet = new Progress();
 514                 Progress pgProcess = new Progress();
 515
 516                 pg.setMinMax(0, 2);
 517                 pg.addProgress(pgGet, 1);
 518                 pg.addProgress(pgProcess, 1);
 519
 520                 Story story = null;
 521                 File file = null;
 522
 523                 if (luid != null && meta != null) {
 524                         file = getFile(luid, pgGet);
 525                 }
 526
 527                 pgGet.done();
 528                 try {
 529                         if (file != null) {
 530                                 SupportType type = SupportType.valueOfAllOkUC(meta.getType());
 531                                 if (type == null) {
 532                                         throw new IOException("Unknown type: " + meta.getType());
 533                                 }
 534
 535                                 URL url = file.toURI().toURL();
 536                                 story = BasicSupport.getSupport(type, url) //
 537                                                 .process(pgProcess);
 538
 539                                 // Because we do not want to clear the meta cache:
 540                                 meta.setCover(story.getMeta().getCover());
 541                                 meta.setResume(story.getMeta().getResume());
 542                                 story.setMeta(meta);
 543                         }
 544                 } catch (IOException e) {
 545                         // We should not have not-supported files in the library
 546                         Instance.getInstance().getTraceHandler()
 547                                         .error(new IOException(String.format(
 548                                                         "Cannot load file of type '%s' from library: %s",
 549                                                         meta.getType(), file), e));
 550                 } finally {
 551                         pgProcess.done();
 552                         pg.done();
 553                 }
 554
 555                 return story;
 556         }
 557
 558         /**
 559          * Import the {@link Story} at the given {@link URL} into the
 560          * {@link BasicLibrary}.
 561          *
 562          * @param url
 563          *            the {@link URL} to import
 564          * @param pg
 565          *            the optional progress reporter
 566          *
 567          * @return the imported Story {@link MetaData}
 568          *
 569          * @throws UnknownHostException
 570          *             if the host is not supported
 571          * @throws IOException
 572          *             in case of I/O error
 573          */
 574         public MetaData imprt(URL url, Progress pg) throws IOException {
 575                 if (pg == null)
 576                         pg = new Progress();
 577
 578                 pg.setMinMax(0, 1000);
 579                 Progress pgProcess = new Progress();
 580                 Progress pgSave = new Progress();
 581                 pg.addProgress(pgProcess, 800);
 582                 pg.addProgress(pgSave, 200);
 583
 584                 BasicSupport support = BasicSupport.getSupport(url);
 585                 if (support == null) {
 586                         throw new UnknownHostException("" + url);
 587                 }
 588
 589                 Story story = save(support.process(pgProcess), pgSave);
 590                 pg.setName(story.getMeta().getTitle());
 591                 pg.done();
 592
 593                 return story.getMeta();
 594         }
 595
 596         /**
 597          * Import the story from one library to another, and keep the same LUID.
 598          *
 599          * @param other
 600          *            the other library to import from
 601          * @param luid
 602          *            the Library UID
 603          * @param pg
 604          *            the optional progress reporter
 605          *
 606          * @throws IOException
 607          *             in case of I/O error
 608          */
 609         public void imprt(BasicLibrary other, String luid, Progress pg)
 610                         throws IOException {
 611                 Progress pgGetStory = new Progress();
 612                 Progress pgSave = new Progress();
 613                 if (pg == null) {
 614                         pg = new Progress();
 615                 }
 616
 617                 pg.setMinMax(0, 2);
 618                 pg.addProgress(pgGetStory, 1);
 619                 pg.addProgress(pgSave, 1);
 620
 621                 Story story = other.getStory(luid, pgGetStory);
 622                 if (story != null) {
 623                         story = this.save(story, luid, pgSave);
 624                         pg.done();
 625                 } else {
 626                         pg.done();
 627                         throw new IOException("Cannot find story in Library: " + luid);
 628                 }
 629         }
 630
 631         /**
 632          * Export the {@link Story} to the given target in the given format.
 633          *
 634          * @param luid
 635          *            the {@link Story} ID
 636          * @param type
 637          *            the {@link OutputType} to transform it to
 638          * @param target
 639          *            the target to save to
 640          * @param pg
 641          *            the optional progress reporter
 642          *
 643          * @return the saved resource (the main saved {@link File})
 644          *
 645          * @throws IOException
 646          *             in case of I/O error
 647          */
 648         public File export(String luid, OutputType type, String target, Progress pg)
 649                         throws IOException {
 650                 Progress pgGetStory = new Progress();
 651                 Progress pgOut = new Progress();
 652                 if (pg != null) {
 653                         pg.setMax(2);
 654                         pg.addProgress(pgGetStory, 1);
 655                         pg.addProgress(pgOut, 1);
 656                 }
 657
 658                 BasicOutput out = BasicOutput.getOutput(type, false, false);
 659                 if (out == null) {
 660                         throw new IOException("Output type not supported: " + type);
 661                 }
 662
 663                 Story story = getStory(luid, pgGetStory);
 664                 if (story == null) {
 665                         throw new IOException("Cannot find story to export: " + luid);
 666                 }
 667
 668                 return out.process(story, target, pgOut);
 669         }
 670
 671         /**
 672          * Save a {@link Story} to the {@link BasicLibrary}.
 673          *
 674          * @param story
 675          *            the {@link Story} to save
 676          * @param pg
 677          *            the optional progress reporter
 678          *
 679          * @return the same {@link Story}, whose LUID may have changed
 680          *
 681          * @throws IOException
 682          *             in case of I/O error
 683          */
 684         public Story save(Story story, Progress pg) throws IOException {
 685                 return save(story, null, pg);
 686         }
 687
 688         /**
 689          * Save a {@link Story} to the {@link BasicLibrary} -- the LUID <b>must</b>
 690          * be correct, or NULL to get the next free one.
 691          * <p>
 692          * Will override any previous {@link Story} with the same LUID.
 693          *
 694          * @param story
 695          *            the {@link Story} to save
 696          * @param luid
 697          *            the <b>correct</b> LUID or NULL to get the next free one
 698          * @param pg
 699          *            the optional progress reporter
 700          *
 701          * @return the same {@link Story}, whose LUID may have changed
 702          *
 703          * @throws IOException
 704          *             in case of I/O error
 705          */
 706         public synchronized Story save(Story story, String luid, Progress pg)
 707                         throws IOException {
 708                 if (pg == null) {
 709                         pg = new Progress();
 710                 }
 711
 712                 Instance.getInstance().getTraceHandler().trace(
 713                                 this.getClass().getSimpleName() + ": saving story " + luid);
 714
 715                 // Do not change the original metadata, but change the original story
 716                 MetaData meta = story.getMeta().clone();
 717                 story.setMeta(meta);
 718
 719                 pg.setName("Saving story");
 720
 721                 if (luid == null || luid.isEmpty()) {
 722                         meta.setLuid(String.format("%03d", getNextId()));
 723                 } else {
 724                         meta.setLuid(luid);
 725                 }
 726
 727                 if (luid != null && getInfo(luid) != null) {
 728                         delete(luid);
 729                 }
 730
 731                 story = doSave(story, pg);
 732
 733                 updateInfo(story.getMeta());
 734
 735                 Instance.getInstance().getTraceHandler()
 736                                 .trace(this.getClass().getSimpleName() + ": story saved ("
 737                                                 + luid + ")");
 738
 739                 pg.setName(meta.getTitle());
 740                 pg.done();
 741                 return story;
 742         }
 743
 744         /**
 745          * Delete the given {@link Story} from this {@link BasicLibrary}.
 746          *
 747          * @param luid
 748          *            the LUID of the target {@link Story}
 749          *
 750          * @throws IOException
 751          *             in case of I/O error
 752          */
 753         public synchronized void delete(String luid) throws IOException {
 754                 Instance.getInstance().getTraceHandler().trace(
 755                                 this.getClass().getSimpleName() + ": deleting story " + luid);
 756
 757                 doDelete(luid);
 758                 invalidateInfo(luid);
 759
 760                 Instance.getInstance().getTraceHandler()
 761                                 .trace(this.getClass().getSimpleName() + ": story deleted ("
 762                                                 + luid + ")");
 763         }
 764
 765         /**
 766          * Change the type (source) of the given {@link Story}.
 767          *
 768          * @param luid
 769          *            the {@link Story} LUID
 770          * @param newSource
 771          *            the new source
 772          * @param pg
 773          *            the optional progress reporter
 774          *
 775          * @throws IOException
 776          *             in case of I/O error or if the {@link Story} was not found
 777          */
 778         public synchronized void changeSource(String luid, String newSource,
 779                         Progress pg) throws IOException {
 780                 MetaData meta = getInfo(luid);
 781                 if (meta == null) {
 782                         throw new IOException("Story not found: " + luid);
 783                 }
 784
 785                 changeSTA(luid, newSource, meta.getTitle(), meta.getAuthor(), pg);
 786         }
 787
 788         /**
 789          * Change the title (name) of the given {@link Story}.
 790          *
 791          * @param luid
 792          *            the {@link Story} LUID
 793          * @param newTitle
 794          *            the new title
 795          * @param pg
 796          *            the optional progress reporter
 797          *
 798          * @throws IOException
 799          *             in case of I/O error or if the {@link Story} was not found
 800          */
 801         public synchronized void changeTitle(String luid, String newTitle,
 802                         Progress pg) throws IOException {
 803                 MetaData meta = getInfo(luid);
 804                 if (meta == null) {
 805                         throw new IOException("Story not found: " + luid);
 806                 }
 807
 808                 changeSTA(luid, meta.getSource(), newTitle, meta.getAuthor(), pg);
 809         }
 810
 811         /**
 812          * Change the author of the given {@link Story}.
 813          *
 814          * @param luid
 815          *            the {@link Story} LUID
 816          * @param newAuthor
 817          *            the new author
 818          * @param pg
 819          *            the optional progress reporter
 820          *
 821          * @throws IOException
 822          *             in case of I/O error or if the {@link Story} was not found
 823          */
 824         public synchronized void changeAuthor(String luid, String newAuthor,
 825                         Progress pg) throws IOException {
 826                 MetaData meta = getInfo(luid);
 827                 if (meta == null) {
 828                         throw new IOException("Story not found: " + luid);
 829                 }
 830
 831                 changeSTA(luid, meta.getSource(), meta.getTitle(), newAuthor, pg);
 832         }
 833
 834         /**
 835          * Change the Source, Title and Author of the {@link Story} in one single
 836          * go.
 837          *
 838          * @param luid
 839          *            the {@link Story} LUID
 840          * @param newSource
 841          *            the new source
 842          * @param newTitle
 843          *            the new title
 844          * @param newAuthor
 845          *            the new author
 846          * @param pg
 847          *            the optional progress reporter
 848          *
 849          * @throws IOException
 850          *             in case of I/O error or if the {@link Story} was not found
 851          */
 852         protected synchronized void changeSTA(String luid, String newSource,
 853                         String newTitle, String newAuthor, Progress pg) throws IOException {
 854                 MetaData meta = getInfo(luid);
 855                 if (meta == null) {
 856                         throw new IOException("Story not found: " + luid);
 857                 }
 858
 859                 meta.setSource(newSource);
 860                 meta.setTitle(newTitle);
 861                 meta.setAuthor(newAuthor);
 862                 saveMeta(meta, pg);
 863         }
 864
 865         /**
 866          * Save back the current state of the {@link MetaData} (LUID <b>MUST NOT</b>
 867          * change) for this {@link Story}.
 868          * <p>
 869          * By default, delete the old {@link Story} then recreate a new
 870          * {@link Story}.
 871          * <p>
 872          * Note that this behaviour can lead to data loss in case of problems!
 873          *
 874          * @param meta
 875          *            the new {@link MetaData} (LUID <b>MUST NOT</b> change)
 876          * @param pg
 877          *            the optional {@link Progress}
 878          *
 879          * @throws IOException
 880          *             in case of I/O error or if the {@link Story} was not found
 881          */
 882         protected synchronized void saveMeta(MetaData meta, Progress pg)
 883                         throws IOException {
 884                 if (pg == null) {
 885                         pg = new Progress();
 886                 }
 887
 888                 Progress pgGet = new Progress();
 889                 Progress pgSet = new Progress();
 890                 pg.addProgress(pgGet, 50);
 891                 pg.addProgress(pgSet, 50);
 892
 893                 Story story = getStory(meta.getLuid(), pgGet);
 894                 if (story == null) {
 895                         throw new IOException("Story not found: " + meta.getLuid());
 896                 }
 897
 898                 // TODO: this is not safe!
 899                 delete(meta.getLuid());
 900                 story.setMeta(meta);
 901                 save(story, meta.getLuid(), pgSet);
 902
 903                 pg.done();
 904         }
 905 }