Exemple #1
0
 public void Load(BCRUser user)
 {
     using (SQLiteDataReader reader = Database.Instance.ExecuteReader(@"SELECT open_current_comic_at_launch, open_next_comic, page_fit_mode,
         zoom_on_tap, toggle_paging_bar, use_page_turn_drag, page_turn_drag_threshold, use_page_change_area, page_change_area_width, use_comicrack_progress
         FROM user_settings WHERE user_id = " + user.UserId + " LIMIT 1;"))
     {
         if (reader.Read())
         {
             try
             {
                 open_current_comic_at_launch = reader.GetBoolean(0);
                 open_next_comic          = reader.GetBoolean(1);
                 page_fit_mode            = reader.GetInt32(2);
                 zoom_on_tap              = reader.GetInt32(3);
                 toggle_paging_bar        = reader.GetInt32(4);
                 use_page_turn_drag       = reader.GetBoolean(5);
                 page_turn_drag_threshold = reader.GetInt32(6);
                 use_page_change_area     = reader.GetBoolean(7);
                 page_change_area_width   = reader.GetInt32(8);
                 use_comicrack_progress   = reader.GetBoolean(9);
                 full_name = user.FullName;
             }
             catch (Exception ex)
             {
                 Trace.WriteLine(ex);
             }
         }
     }
 }
Exemple #2
0
        // TODO: add timeout for apikey.
        public static IUserIdentity GetUserFromApiKey(string apiKey)
        {
            if (apiKey == null)
            {
                return(null);
            }

            BCRUser user;

            if (users.TryGetValue(apiKey, out user))
            {
                return(user);
            }

            NameValueCollection result = Database.Instance.QuerySingle("SELECT user.id as id, username, apikey, fullname FROM user JOIN user_apikeys ON user.id=user_apikeys.user_id WHERE apikey = '" + apiKey + "' LIMIT 1;");

            if (result == null)
            {
                return(null);
            }

            user = new BCRUser {
                UserName = result["username"], UserId = Convert.ToInt32(result["id"]), FullName = result["fullname"]
            };
            user.Initialize();

            lock (lockObject)
            {
                users[apiKey] = user;
            }

            return(user);
        }
Exemple #3
0
        // Cache expensive properties
        // Drawback: any updates to the original ComicBook will not be propagated.
        // However, this Comic class is not meant to be used for a long time. It is used for providing a
        // json serializable class for returning search results.

        //private readonly Lazy<string> _caption = null;
        //public string Caption { get { return _caption.Value; } }
        #endregion Fields

        #region Constructors

        public Comic(ComicBook source, BCRUser user)
        {
            book = source;
            useComicrackProgress = user.settings.use_comicrack_progress;
            progress             = useComicrackProgress ? null : user.GetComicProgress(source.Id);

            //_caption = new Lazy<string>(() => { return book.Caption; });
        }
Exemple #4
0
        public void Save(BCRUser user)
        {
            string s = String.Format("UPDATE user_settings SET open_current_comic_at_launch={0}, open_next_comic={1}, page_fit_mode={2}," +
                                     "zoom_on_tap={3}, toggle_paging_bar={4}, use_page_turn_drag={5}, page_turn_drag_threshold={6}, use_page_change_area={7}," +
                                     "page_change_area_width={8}, use_comicrack_progress={9} WHERE user_id={10};", open_current_comic_at_launch?1:0, open_next_comic?1:0, page_fit_mode,
                                     zoom_on_tap, toggle_paging_bar, use_page_turn_drag?1:0, page_turn_drag_threshold, use_page_change_area?1:0, page_change_area_width, use_comicrack_progress?1:0, user.UserId);

            Database.Instance.ExecuteNonQuery(s);
        }
Exemple #5
0
        // Get all comics added within x days
        public static IEnumerable <Comic> GetMostRecentlyAdded(BCRUser user, int days)
        {
            //comicrack format = "Added": "10/15/2018 10:51:25 AM"
            //string dateformat = "MM/dd/yyyy HH':'mm':'ss ";
            var books  = ComicRackAPIServer.Plugin.Application.GetLibraryBooks();
            var recent = books.Where(x => x.AddedTime >= DateTime.Today.AddDays(-(days)));
            var list   = recent.Select(x => x.ToComic(user))
                         .OrderBy(x => x.Added).ToList();

            return(list);
        }
Exemple #6
0
        public static IEnumerable <Comic> GetComicsForList(BCRUser user, Guid id)
        {
            var list = Program.Database.ComicLists.FindItem(id);

            if (list == null)
            {
                return(Enumerable.Empty <Comic>());
            }

            return(list.GetBooks().Select(x => x.ToComic(user)));
        }
Exemple #7
0
        // Get all comics from a specific series and volume
        public static IEnumerable <Comic> GetComicsFromSeriesVolume(BCRUser user, Guid id, int volume)
        {
            var books  = ComicRackAPIServer.Plugin.Application.GetLibraryBooks();
            var book   = books.Where(x => x.Id == id).First();
            var series = books.Where(x => x.ShadowSeries == book.ShadowSeries)
                         .Where(x => x.ShadowVolume == volume)
                         .Select(x => x.ToComic(user))
                         .OrderBy(x => x.ShadowNumber).ToList();

            return(series);
        }
Exemple #8
0
        /*
         *
         */
        public static IEnumerable <Comic> GetSeries(BCRUser user, Guid id, NancyContext context)
        {
            var books  = ComicRackAPIServer.Plugin.Application.GetLibraryBooks();
            var book   = books.Where(x => x.Id == id).First();
            var series = books.Where(x => x.ShadowSeries == book.ShadowSeries)
                         .Where(x => x.ShadowVolume == book.ShadowVolume)
                         .Select(x => x.ToComic(user))
                         .OrderBy(x => x.ShadowNumber).ToList();

            int totalCount = 0;

            return(context.ApplyODataUriFilter(series, ref totalCount).Cast <Comic>());
        }
Exemple #9
0
 public static Comic GetComic(BCRUser user, Guid id)
 {
     try
     {
         var comic = GetComics().First(x => x.Id == id);
         return(comic.ToComic(user));
     }
     catch//(Exception e)
     {
         //MessageBox.Show(e.ToString());
         return(null);
     }
 }
Exemple #10
0
 public static Comic ToComic(this ComicBook x, BCRUser user)
 {
     return(new Comic(x, user));
 }
Exemple #11
0
        public BCRModule()
            : base(Database.Instance.GlobalSettings.url_base + "/BCR")
        {
            // The user must be authenticated in order to use the BCR API.
            this.RequiresAuthentication();

            Get["/"] = x => { return(Response.AsText("Authentication OK")); };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Retrieve a list of all (smart)lists.
            Get["/Lists"] = x => {
                try
                {
                    //var user = (BCRUser)this.Context.CurrentUser;
                    //Gui guid = user.GetHomeList();
                    //ComicListItem item = Program.Database.ComicLists.GetItems<ComicListItem>(false).FirstOrDefault((ComicListItem cli) => cli.Id == s);

                    int depth = Request.Query.depth.HasValue ? int.Parse(Request.Query.depth) : -1;
                    return(Response.AsOData(Program.Database.ComicLists.Select(c => c.ToComicList(depth))));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Retrieve the contents of the specified list.
            Get["/Lists/{id}"] = x => {
                try
                {
                    int depth = Request.Query.depth.HasValue ? int.Parse(Request.Query.depth) : -1;
                    IEnumerable <ComicList> list = Program.Database.ComicLists.Where(c => c.Id == new Guid(x.id)).Select(c => c.ToComicList(depth));
                    if (list.Count() == 0)
                    {
                        return(Response.AsError(HttpStatusCode.NotFound, "List not found", Request));
                    }

                    return(Response.AsOData(list));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // For OData compatibility, count should be $count, but I don't know how to parse the $ with Nancy....
            Get["/Lists/{id}/Comics/count"] = x => {
                try
                {
                    BCRUser user       = (BCRUser)this.Context.CurrentUser;
                    int     totalCount = 0;
                    return(Response.AsText(Context.ApplyODataUriFilter(BCR.GetComicsForList(user, new Guid(x.id)), ref totalCount).Count().ToString()));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Return the comics of the specified list using OData to filter the comic properties and the list paging.
            Get["/Lists/{id}/Comics"] = x => {
                try
                {
                    BCRUser user = (BCRUser)this.Context.CurrentUser;

                    var rawcomics = BCR.GetComicsForList(user, new Guid(x.id));
                    int propCount = rawcomics.Count();
                    var result    = new { totalCount = propCount, items = rawcomics };
                    return(Response.AsJson(result, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };

            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Return the Library Totals.
            Get["/Totals"] = x => {
                try
                {
                    BCRUser user            = (BCRUser)this.Context.CurrentUser;
                    var     comics          = BCR.GetComics().Select(c => c.ToComic(user));
                    var     series          = BCR.GetSeries();
                    var     publishers      = BCR.GetPublishers();
                    int     issuesCount     = comics.Count();
                    int     seriesCount     = series.Count();
                    int     publishersCount = publishers.Count();
                    var     result          = new { issues = issuesCount, series = seriesCount, publishers = publishersCount };
                    return(Response.AsJson(result, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };

            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Returns a list of all the comics as comic excerpts
            Get["/Comics"] = x => {
                try
                {
                    BCRUser user      = (BCRUser)this.Context.CurrentUser;
                    var     comics    = BCR.GetComics().Select(c => c.ToComic(user));
                    int     propCount = comics.Count();
                    var     result    = new { totalCount = propCount, items = comics };
                    return(Response.AsJson(result, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Return the comicbook info as an OData filtered bag of properties.
            Get["/Comics/{id}"] = x => {
                try
                {
                    BCRUser user  = (BCRUser)this.Context.CurrentUser;
                    Comic   comic = BCR.GetComic(user, new Guid(x.id));
                    if (comic == null)
                    {
                        return(Response.AsError(HttpStatusCode.NotFound, "Comic not found", Request));
                    }

                    return(Response.AsOData(new List <Comic> {
                        comic
                    }));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Retrieve the specified page as a jpg file with the specified dimensions.
            Get["/Comics/{id}/Pages/{page}"] = x => {
                try
                {
                    int width  = Request.Query.width.HasValue ? int.Parse(Request.Query.width) : -1;
                    int height = Request.Query.height.HasValue ? int.Parse(Request.Query.height) : -1;

                    int maxWidth  = Request.Query.maxWidth.HasValue ? int.Parse(Request.Query.maxWidth) : -1;
                    int maxHeight = Request.Query.maxHeight.HasValue ? int.Parse(Request.Query.maxHeight) : -1;

                    return(BCR.GetPageImage(new Guid(x.id), int.Parse(x.page), width, height, Response));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Retrieve the original size (in pixels) of the requested page.
            Get["/Comics/{id}/Pages/{page}/size"] = x => {
                try
                {
                    int width  = 0;
                    int height = 0;
                    BCR.GetPageImageSize(new Guid(x.id), int.Parse(x.page), ref width, ref height);
                    return(Response.AsJson(new { width = width, height = height }, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };

            Get["/Comics/{id}/pagesizes"] = x => {
                try
                {
                    //   int width = 0;
                    //     int height = 0;
                    //  int pageCnt = 0;
                    //      List<PageSizes> pagesizes = new List<PageSizes>();
                    //    BCRUser user = (BCRUser)this.Context.CurrentUser;
                    //      Comic comic = BCR.GetComic(user, new Guid(x.id));
                    var pages = BCR.GetPagesInfo(new Guid(x.id));
                    if (pages == null)
                    {
                        return(Response.AsError(HttpStatusCode.NotFound, "Comic not found", Request));
                    }

                    // pageCnt = comic.PageCount;
                    //  for (int i = 0; i < pageCnt; i++)
                    // {
                    //BCR.GetPageImageSize(new Guid(x.id), i, ref width, ref height);
                    //pagesizes.Add(new PageSizes { pageNbr = i, height = height, width = width, ratio = width / height });
                    // }

                    return(Response.AsJson(pages, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };

            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Get one property.

            /*
             * Get["/Comics/{id}/{property}"] = x => {
             * try
             * {
             * Comic comic = BCR.GetComic(new Guid(x.id));
             * if (comic == null)
             * {
             *  return Response.AsError(HttpStatusCode.NotFound, "Comic not found", Request);
             * }
             *
             * PropertyInfo property = comic.GetType().GetProperty(x.property);
             * object value = property.GetValue(comic, null);
             *
             * return Response.AsJson(value);
             * }
             * catch(Exception e)
             * {
             *  return Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request);
             * }
             * };
             */


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Update properties of the specified comicbook.

            /*
             * Put["/Comics/{id}"] = x => {
             * try
             * {
             * // Get the ComicBook entry from the library, so we can change it.
             * ComicBook book = BCR.GetComicBook(new Guid(x.id));
             * if (book == null)
             * {
             *  return Response.AsError(HttpStatusCode.NotFound, "Comic not found", Request);
             * }
             *
             * // Convert form values to temporary ComicBook object.
             * ComicBook info = this.Bind<ComicBook>();
             *
             * IEnumerable<string> keys = Request.Form.GetDynamicMemberNames();
             *
             * // This also triggers the update of the ComicRack application.
             * book.CopyDataFrom(info, keys);
             *
             * return HttpStatusCode.OK;
             * }
             * catch(Exception e)
             * {
             *  return Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request);
             * }
             * };
             */

            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Update properties of the specified comicbook for the current user
            Post["/Comics/{id}/Progress"] = x => {
                try
                {
                    // Check if the comic exists.


                    Guid      comicId = new Guid(x.id);
                    ComicBook book    = BCR.GetComics().FirstOrDefault(comic => comic.Id == comicId);
                    if (book == null)
                    {
                        return(Response.AsError(HttpStatusCode.NotFound, "Comic not found", Request));
                    }

                    BCRUser user = (BCRUser)this.Context.CurrentUser;
                    user.UpdateComicProgress(book, int.Parse(this.Request.Form.CurrentPage));
                    //if using multiple users do we update the master file with a users progress?
                    //book.SetValue("CurrentPage", int.Parse(this.Request.Form.CurrentPage));
                    return(HttpStatusCode.OK);
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };

            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Update one property

            /*
             * Put["/Comics/{id}/{property}"] = x => {
             * try
             * {
             * // Convert form values to temporary Comic object.
             * string info = this.Bind<string>();
             *
             *
             * // Now get the ComicBook entry from the library, so we can change it.
             * ComicBook book = BCR.GetComicBook(x.id);
             * if (book == null)
             * {
             *  return Response.AsError(HttpStatusCode.NotFound, "Comic not found", Request);
             * }
             *
             * // Setting one of these values also triggers the update of the ComicRack application.
             * book.SetValue(x.property, info);
             *
             *
             * return HttpStatusCode.OK;
             * }
             * catch(Exception e)
             * {
             *  return Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request);
             * }
             * };
             */


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Get the BCR settings.
            Get["/Settings"] = x => {
                try
                {
                    var user = (BCRUser)this.Context.CurrentUser;
                    return(Response.AsJson(user.GetSettings(), HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Update the BCR settings.
            Put["/Settings"] = x => {
                try
                {
                    var user = (BCRUser)this.Context.CurrentUser;
                    user.UpdateSettings(this.Bind <UserSettings>());

                    return(HttpStatusCode.OK);
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };

            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Get a list of series
            Get["/Series"] = x => {
                try
                {
                    var user      = (BCRUser)this.Context.CurrentUser;
                    var series    = BCR.GetSeriesList();
                    int propCount = series.Count();
                    var result    = new { totalCount = propCount, items = series };
                    return(Response.AsJson(result, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };
            // Get a list of series added in the last 2 days
            Get["/Series/Recent/{days}"] = x => {
                try
                {
                    var user      = (BCRUser)this.Context.CurrentUser;
                    int days      = x.days;
                    var series    = BCR.GetMostRecentlyAdded(user, days);
                    int propCount = series.Count();
                    var result    = new { totalCount = propCount, items = series };
                    return(Response.AsJson(result, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };
            // Get a list of series Read in the last 2 days
            Get["/Series/RecentlyRead/{days}"] = x => {
                try
                {
                    var user      = (BCRUser)this.Context.CurrentUser;
                    int days      = x.days;
                    var series    = BCR.GetMostRecentlyRead(user, days);
                    int propCount = series.Count();
                    var result    = new { totalCount = propCount, items = series };
                    return(Response.AsJson(result, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };
            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Retrieve a list of all comics in the specified list
            Get["/Series/{id}"] = x => {
                try
                {
                    var user      = (BCRUser)this.Context.CurrentUser;
                    var series    = BCR.GetComicsFromSeries(user, new Guid(x.id));
                    int propCount = series.Count();
                    var result    = new { totalCount = propCount, items = series };
                    return(Response.AsJson(result, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Retrieve the number of comics in the specified list
            Get["/Series/{id}/count"] = x => {
                try
                {
                    var user       = (BCRUser)this.Context.CurrentUser;
                    int totalCount = 0;
                    return(Response.AsText(Context.ApplyODataUriFilter(BCR.GetComicsFromSeries(user, new Guid(x.id)), ref totalCount).Count().ToString()));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            //
            Get["/Series/{id}/Volumes"] = x => {
                try
                {
                    return(Response.AsOData(BCR.GetVolumesFromSeries(new Guid(x.id)), HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            //
            Get["/Series/{id}/Volumes/{volume}"] = x => {
                try
                {
                    BCRUser user   = (BCRUser)this.Context.CurrentUser;
                    int     volume = int.Parse(x.volume);
                    var     comics = BCR.GetComicsFromSeriesVolume(user, new Guid(x.id), volume);
                    return(Response.AsOData(comics, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Get a list of publishers
            Get["/Publishers"] = x => {
                try
                {
                    var publishers = BCR.GetPublishers();
                    int propCount  = publishers.Count();
                    var result     = new { totalCount = propCount, items = publishers };
                    return(Response.AsJson(result, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };

            Get["/Publishers/{publisher}/Imprint/{imprint}/"] = x => {
                try
                {
                    var user    = (BCRUser)this.Context.CurrentUser;
                    var pub     = x.publisher;
                    var imprint = x.imprint;
                    if (string.IsNullOrEmpty(imprint))
                    {
                        imprint = "";
                    }
                    var series = BCR.GetSeries(pub, imprint);
                    // int propCount = series.Count();
                    var result = new { items = series };
                    return(Response.AsJson(result, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            Get["/Ratings"] = x => {
                try
                {
                    var series    = BCR.GetAgeRatings();
                    int propCount = series.Count();
                    var result    = new { totalCount = propCount, items = series };
                    return(Response.AsJson(result, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };

            Get["/Rating/{rating}/"] = x => {
                try
                {
                    var    user   = (BCRUser)this.Context.CurrentUser;
                    string rating = x.rating;
                    // replace ~ with +
                    rating = rating.Replace('~', '+');
                    if (string.IsNullOrEmpty(rating))
                    {
                        rating = "";
                    }
                    var series    = BCR.GetSeriesByAgeRating(rating);
                    int propCount = series.Count();
                    var result    = new { totalCount = propCount, items = series };
                    return(Response.AsJson(result, HttpStatusCode.OK));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };

            ///////////////////////////////////////////////////////////////////////////////////////////////
            //
            Get["/Log"] = x => {
                try
                {
                    string severity = Request.Query.sev.HasValue ? Request.Query.sev : "";
                    string message  = Request.Query.msg.HasValue ? Request.Query.msg : "";

                    // TODO: write log entry to a file.

                    return(Response.AsRedirect("/tablet/resources/images/empty_1x1.png", RedirectResponse.RedirectType.Permanent));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Get the list of watched folders.
            Get["/WatchFolder"] = x => {
                try
                {
                    //return Response.AsOData(BCR.GetPublishers(), HttpStatusCode.OK);

                    var folders = Program.Database.WatchFolders as cYo.Projects.ComicRack.Engine.Database.WatchFolderCollection;

                    List <string> books = BCRExtensions.GetFolderBookList2(folders.Folders.First(), true);
                    return(Response.AsJson(books, HttpStatusCode.OK));

                    //return Response.AsRedirect("/tablet/resources/images/empty_1x1.png", RedirectResponse.RedirectType.Permanent);
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };


            ///////////////////////////////////////////////////////////////////////////////////////////////
            // Get list of all files in the folder
            Get["/WatchFolder/{folder}"] = x => {
                try
                {
                    return(Response.AsRedirect("/tablet/resources/images/empty_1x1.png", RedirectResponse.RedirectType.Permanent));
                }
                catch (Exception e)
                {
                    return(Response.AsError(HttpStatusCode.InternalServerError, e.ToString(), Request));
                }
            };
        }