Patent Application
20210263997
The field of the invention is website generation technologies.
The background description includes information that may be useful in understanding the present invention. It is not an admission that any of the information provided in this application is prior art or relevant to the presently claimed invention, or that any publication specifically or implicitly referenced is prior art.
Sharing content is an integral part of using the Internet, and the way in which Internet users share content is constantly evolving. Oftentimes, people share single items of content directly with one another, and that is fine for things like news articles, pictures, podcasts, etc. But in many instances, people want to be able to share more than one item of content with many people at once. One of the best ways to do that is to make that content publicly available all in one place by building a website.
But building a website is not a trivial endeavor. Even when using a service designed to make building a website simple, users are required to do the labor of building each page on a site according to a theme. The content that goes onto a website must be manually entered onto the site according to the restrictions of that theme, which requires a user to do quite a lot more work than is warranted for the simple desire of sharing content.
Thus, developments in content sharing have failed to appreciate advancements in website building technology that facilitate simple and quick creation of websites for sharing all kinds of content.
These and all other extrinsic materials discussed in this application are incorporated by reference in their entirety. Where a definition or use of a term in an incorporated reference is inconsistent or contrary to the definition of that term provided in this application, the definition of that term provided in this application applies and the definition of that term in the reference does not apply.
Thus, there is still a need in the art for improved website generating technologies.
The present invention provides systems and methods of website generation using locally and remotely stored content. One aspect of the inventive subject matter contemplates a method of generating a website, where the method includes the steps of: receiving, from a client, a request to add an item to a source folder, the request including an upload file attribute having a filename and a content type where the upload file attribute is associated with the item, and a save-to-folder identifier associated with the source folder; sending, to the client, a response to the request, the response including a source folder identifier and item attributes that include an item type and a URL; receiving, from the client, a website creation request, the website creation request including the source folder identifier; generating the website and a website URL, wherein the website is accessible by the website URL and the website comprises the item in the source folder; and sending, to the client, a website creation response, the website creation response comprising the website URL. In some embodiments, the item attributes can include a MIME type.
In some embodiments, the request to add an item to a source folder also includes one, or any combination of: an annotation attribute associated with the item; a title attribute comprising a title of the item; a title assignment attribute; an annotation assignment attribute; an image assignment attribute; an add-to-folder type; a URL associated with the item; and a save method attribute.
In some embodiments, the save-to-folder identifier can include a token that is associated with the source folder. In the same or other embodiments, the save-to-folder identifier is the same as the source folder identifier.
It is contemplated that the response to the request to add an item to a source folder can additionally include one, or any combination of: a completion status indicator; a created-at indicator; a data-storage-usage indicator; a description; image attributes; a title; and a name.
In some embodiments, the website creation request further comprises one, or any combination of: a name; a subtitle; a description; an image URL; and a theme. The response to the website creation request can additionally include one, or any combination of: author attributes comprising an author name and an author avatar; an author identifier; an analytics ID; a created-at attribute; a data storage usage attribute; a description; a website image; a website name; the source folder identifier; and a visual completion status.
Another aspect of the inventive subject matter contemplates a method of generating a website that includes the steps of: receiving, from a client, a set of user-selected items, the set of user-selected items including at least a first website address and a second website address; adding the set of user-selected items to a source folder having an associated source folder identifier; receiving, from the client, a request to create a website, the request comprising the source folder identifier; generating item representatives, each of the item representatives comprising at least one of a text block and an image corresponding to one of the set of user-selected items; generating the website using the item representatives; and sending, to the client, a URL corresponding to the website.
In some embodiments, the request to create a website can also include a user-selected theme, where the website is generated at least in part according to the user-selected theme. In the same or other embodiments, the source folder identifier comprises a source folder token, and the source folder token can be, or include, a UUID.
Another aspect of the inventive subject matter contemplates a method of generating a website that includes the steps of: receiving, from a client, a set of user-selected items, the set of user-selected items comprising at least a first website address and a second website address; adding the set of user-selected items to a source folder having an associated source folder identifier, wherein the first website address is assigned to a first subfolder within the source folder, and wherein the second website address is assigned to a second subfolder within the source folder; receiving, from the client, a request to create a website, the request comprising the source folder identifier; generating item representatives for each item of the set of user-selected items, each of the item representatives comprising at least one of a description and an image; and generating a website using the item representatives, where the generated website includes a first section based on the first subfolder and a second section based on the second subfolder.
In some embodiments, the request to create a website further comprises a user selected theme, and the website can then be generated according to the user-selected theme. The source folder identifier can include a source folder token, and the source folder token can be, or include, a UUID.
Various objects, features, aspects and advantages of the inventive subject matter will become more apparent from the following detailed description of preferred embodiments, along with the accompanying drawing figures in which like numerals represent like components.
The following discussion provides example embodiments of the inventive subject matter. Although each embodiment represents a single combination of inventive elements, the inventive subject matter is considered to include all possible combinations of the disclosed elements. Thus, if one embodiment comprises elements A, B, and C, and a second embodiment comprises elements B and D, then the inventive subject matter is also considered to include other remaining combinations of A, B, C, or D, even if not explicitly disclosed.
As used in the description in this application and throughout the claims that follow, the meaning of “a,” “an,” and “the” includes plural reference unless the context clearly dictates otherwise. Also, as used in the description in this application, the meaning of “in” includes “in” and “on” unless the context clearly dictates otherwise.
Also, as used in this application, and unless the context dictates otherwise, the term “coupled to” is intended to include both direct coupling (in which two elements that are coupled to each other contact each other) and indirect coupling (in which at least one additional element is located between the two elements). Therefore, the terms “coupled to” and “coupled with” are used synonymously.
It should be noted that any language directed to a computer should be read to include any suitable combination of computing devices, including servers, interfaces, systems, databases, agents, peers, engines, controllers, or other types of computing devices operating individually or collectively. One should appreciate the computing devices comprise a processor configured to execute software instructions stored on a tangible, non-transitory computer readable storage medium (e.g., hard drive, solid state drive, RAM, flash, ROM, etc.). The software instructions preferably configure the computing device to provide the roles, responsibilities, or other functionality as discussed below with respect to the disclosed apparatus. In especially preferred embodiments, the various servers, systems, databases, or interfaces exchange data using standardized protocols or algorithms, possibly based on HTTP, HTTPS, AES, public-private key exchanges, web service APIs, known financial transaction protocols, or other electronic information exchanging methods. Data exchanges preferably are conducted over a packet-switched network, the Internet, LAN, WAN, VPN, or other type of packet switched network. The following description includes information that may be useful in understanding the present invention. It is not an admission that any of the information provided in this application is prior art or relevant to the presently claimed invention, or that any publication specifically or implicitly referenced is prior art.
Methods of the inventive subject matter are directed to on-demand creation of websites using user-selected content. Users frequently need to quickly put together easy-to-access websites using a variety of content that is either remotely stored (e.g., content stored somewhere on the Internet, such as a website, web server, or cloud server(s)) or locally stored (e.g., content that is stored on a user's computer, such as a photograph or PDF document). Methods of the inventive subject matter facilitate creation of websites using any combination of locally and remotely stored content.
Each attribute described in this application can include an array of attributes of that kind. “Array” should be interpreted to mean any data structure—either known or discovered in the future—that is capable of storing the data or information that an array is described as being able to store. A linked list, for example, is included in this definition of “array.” All attributes in this application, unless otherwise stated, should be interpreted as comprising either a single attribute or an array of attributes.
Many of the features and attributes discussed in this application can be applied to or used in all embodiments of the inventive subject matter described in this application, regardless of the embodiment where that attribute is discussed. The same is true for all of the subject matter described in this application unless explicitly stated otherwise.
Further, the steps of methods described in this application can be completed in an order other than that in which they are described, unless specifically described as being executed in a particular order or unless a particular order of execution is necessary to properly carry out the method.
For a server to generate a website using user-selected content, first the user must select and store that content in a way that makes it locally accessible to the server. In step 700, a server receives, from a client, a request to add an item to a source folder. A source folder is managed by the server and can be hosted on the server as well. The source folder is an organizational tool used to group items together, where an “item” is either locally or remotely stored content. An item can be, for example, a photograph, a document (e.g., *.pdf, *.docx, or any other filetype), a website, an audio recording, or any other type of content that can be remotely or locally stored. A user uses their computing device (e.g., where the user's computing device is the “client”) to create the source folder (and optionally, one or more subfolders within the source folder), and also to select an item to add to the source folder. With the item identified, the client sends a request to the server, where the request includes information sufficient to identify the item and it requests that the item be added to the source folder.
Information sufficient to identify the item can include one, or any combination of, the following attributes: an annotation attribute associated with the item; a title attribute comprising a title of the item; an add-to-folder type; an upload file attribute; a URL; a title assignment attribute; an annotation assignment attribute; an image assignment attribute; a save method attribute; a save-to-folder identifier; and a browser attribute.
The add-to-folder type attribute indicates how the item is to be added to the folder. For example, if locally stored content is to be added (e.g., saved) to the folder, then the add-to-folder type attribute could be set to “upload” (e.g., a descriptor stored as a string), indicating that the item will be added to the folder via upload (e.g., from the client). In another example, if remotely stored content such as a website is to be added to the folder, the, the add-to-folder type attribute could be set to “link,” since a website link would be sufficient to identify the website to be added to the source folder. In such a case, the server may then request the relevant item for local storage using the link.
The upload file attribute includes one or both of a filename and a content type. For example, if the item to be added to the source folder is a PDF, then the content type could be “PDF” and the filename can be the name of the PDF file.
In an embodiment where the item to be added to the folder is a website or other remotely stored content that can be accessed using a web address, a URL is included as an attribute. The URL attribute indicates a location where the remotely stored item can be located. In some embodiments, the URL can comprise an IP address, a web address, or other type of resource locator.
A title assignment attribute can also be associated with the item. The title assignment attribute can be a TRUE/FALSE indicator to indicate whether the server or the user will determine the title attribute for the item. For example, if the title assignment attribute is set to TRUE (or 1 or “Yes” or another binary indicator), then the server can automatically extract a title from the corresponding item (e.g., the title of a website, PDF document, etc.) and set that title as the title attribute for the item. If the title assignment attribute is set to FALSE (or 0 or “No” or another binary indicator), then a title provided by the user will be set as the title attribute for the corresponding item. In embodiments, a user can input a title for an item at the time the item is saved to a source folder, or at some later point in time.
An annotation assignment attribute operates similarly to the title assignment attribute. If the annotation assignment attribute is set to TRUE, then the server can automatically extract an annotation (e.g., snippet, summary, or metadata associated with the item) and set that annotation as the annotation attribute for the item. Otherwise, if the annotation assignment attribute it is set to FALSE, then an annotation provided by the user will be set as the annotation attribute for the corresponding item. In embodiments, a user can input an annotation for an item at the time the item is saved to a source folder, or at some later point in time.
An image assignment attribute is another indicator attribute. If the image assignment attribute is set to TRUE, then the server can automatically extract a representative image (e.g., an image contained within the item) and set that image as the image attribute for the item. Otherwise, if the image assignment attribute is set to FALSE, then a representative image selected by the user will be set as the image attribute for the corresponding item. For example, if the item to be added to the source folder is a website having an image associated with it (e.g., a Wikipedia entry having a featured image), then the server can automatically extract that image and set it as the image attribute. Alternatively, the user can select some other representative image to be set as the image attribute. In embodiments, a user can select an image for an item at the time the item is saved to a source folder, or at some later point in time.
A save method attribute indicates how an item is to be saved to the source folder. For example, if an item is locally stored, then the save method attribute can indicate that the save method is “upload.” In embodiments where, for example, the item to be saved to the source folder is remotely stored and can be accessed via URL, then the save method attribute can indicate that the save method is “url_only.”
A save-to-folder identifier can identify, for example, the source folder or a non-permanent folder in which an item (or items, if there are more than one) is temporarily stored before adding it to the source folder. In some embodiments, the save-to-folder identifier is associated with a request to add an item to a source folder such that, for example, a server can distinguish between multiple requests from different clients. In some embodiments, the save-to-folder identifier is a Universally Unique Identifier (UUID), and in other embodiments, the save-to-folder identifier is unique within the server, but not universally unique. In some embodiments, the save-to-folder identifier can be used by the server in the process of generating a source folder (e.g., the source folder does not exist until the request is received and processed by the server), and once the source folder is generated, the save-to-folder identifier can become the source folder identifier, or, in some embodiments, the source folder can be given a new source folder identifier.
Finally, a browser attribute can be included to identify the web browser with which the client sent the request to the server (e.g., Firefox, Chrome, Safari, etc.).
The server, after receiving the request to add an item to the source folder, then saves the item to the source folder, and responds to the request as shown in step 702. Saving an item to a source folder can include, for example, storing an item to a server in such a way that the item can be accessed via the source folder. This can be accomplished in a variety of ways depending on how the server (or other computing device) is configured (e.g., it can depend on the file structure). The response includes one, or any combination of, the following: a completion status indicator; a created-at indicator; a data-storage-usage indicator; a description; image attributes; a name; a title; a source folder identifier; and item attributes corresponding to the item.
A completion status indicator informs the client as to whether activities related to the client's request are completed. In some embodiments, the server's response to the client's request to add an item to the source folder can be sent to the client before all of the server's activities related to saving the item are completed.
A created-at indicator includes information about when the item was created on the server (e.g., when the item was saved to the source folder and recorded in the server as being present in the source folder). In some embodiments, the created-at indicator includes a time and date.
A data-storage-usage indicator can indicate, for example, the amount of memory or storage being used by the item on the server when it is stored in the source folder. This value can be useful to facilitate optimization during website generation. For example, if the data-storage-usage indicator indicates that the item is relatively large (e.g., the item, when included in a generated website, would consume more data than necessary to send to clients on mobile plans with limited data plans), then the item can be optimized during (or before) the website generation step. In some embodiments, optimization can include compressing images into different formats, optimizing documents (e.g., PDFs) to occupy less space, and the like.
A description can include a brief description of the item. The description can be pulled from the content of the item itself (e.g., from the contents of a document or website), or it can be pulled from the item's metadata (e.g., a description that exists in a PDF's metadata).
Image attributes can include information sufficient to describe several aspects of an image associated with an item. For example, the image attributes can include an array of information about an image including a full URL pointing to the original image or to an optimized version of the image, dimensions of the image, a tint, a dominant color of the image, moment data for the image, a URL pointing to a thumbnail of the image, and dimensions of the thumbnail of the image.
A title attribute can include, for example, the title or name of the item. In embodiments where the item is remotely stored (like a website), the title attribute can include information pulled from the website (e.g., a byline, a header, an article title, etc.). In embodiments where the item is locally stored, the title attribute can include the name of the file that is uploaded, or it can include a name stored in the file's metadata.
A title can be a title associated with an item. Thus, a title can include a title that is associated with an uploaded item or a title that is associated with a remotely stored item, based on either the content of the item or the item's metadata (e.g., a document title, an article title, etc.).
A source folder identifier identifies the source folder to which an item or items have been added. A source folder identifier can be a UUID, or it can be unique only at the service-level (e.g., an identifier that is unique to the server, but not universally unique). In some embodiments, the source folder identifier can be a token that is assigned to the source folder by, for example, the server.
In some embodiments, a client can request to add a plurality of items (of the same or different types) to a source folder at the same time (e.g., the request can relate to a website and an uploaded PDF), or a client can make multiple requests (each request to add one or more items to a source folder) before the server responds. Each item in the request(s) has corresponding item attributes, and the item attributes are returned to the client in the server's response to the client's request(s) to add one or more items to a source folder. The item attributes for each item can include one, or any combination of: a MIME attribute; an item type (e.g., upload, link); and a URL.
MIME stands for Multipurpose Internet Mail Extensions. A MIME attribute includes a type and a subtype, which are two strings, separated by a ‘/’. No space is allowed. The type represents the category and can be a discrete or a multipart type. The subtype is specific to each type. MIME types include for example: text, image, audio, video, and application. MIME subtypes include, for example: (for text) plain, HTML, JavaScript, and CSS; (for image) gif, png, jpeg, bmp, and webp; (for audio) midi, mpeg, webm, ogg, and way; (for video) webm and ogg; (for application) octet-stream, pkcs12, vnd.mspowerpoint, xhtml+xml, xml, and pdf.
An item type attribute can be used to identify an item type for the item in the request to add an item to the source folder. For example, an item type attribute can be “upload” for when the item is locally stored content (e.g., content that has to be uploaded to the server such as a document, a video, or an audio file), a “note” for when an item is a user-defined note (e.g., a grocery list), or a “link” for when the item is remotely stored content that is accessible via a link.
A URL can be included in the server's response. In embodiments where the item is locally-stored content, the URL can direct a web browser to a location on the server (e.g., on the same domain as the server, or on a sub-domain of the server that directs clients to the server) where the item, or some portion of the item, can be accessed (e.g., a URL of a location where the item was uploaded onto the server). In embodiments where the item is remotely stored, the URL can direct a web browser to a location on an external server where the item (or some portion of the item) can be accessed. A URL can point to a wide variety of content, including webpages, YouTube videos, images, documents, videos, and audio files.
With the preceding steps completed, the server can add an item to an identified source folder. With one or more items added to a source folder, a user can then request the server to create a website using those items, as shown in step 704. Thus, in step 704, the client sends to the server a website creation request. The website creation request includes one or more of the following attributes: the source folder identifier, the name, a subtitle, a description, an image URL, and a theme.
The source folder identifier is included in the website creation request to help the server to know which source folder to draw from to create the website. Thus, any item or items that have been added to the source folder can be used to create the website subject to the request.
The name included in the website creation request can be, for example, the source folder name. It is also contemplated that the name can be a name for the website that is being requested (e.g., a user-defined name). Other possible name attribute properties are described above.
A subtitle, like other descriptive attributes, can include information that is taken from one or more of the items contained in the source folder, or it can be taken from the source folder itself (e.g., from source folder metadata). In some embodiments, the subtitle attribute can be user-defined.
A description, like other descriptive attributes, can include information that is taken from one or more of the items contained in the source folder (e.g., it can be algorithmically generated based on the contents of the items in the source folder), or it can be taken from the source folder itself (e.g., from source folder metadata). In some embodiments, the description attribute can be user-defined.
An image URL attribute includes a URL that points to an image that is stored either on the server or on a remote server, where the image that the URL points to is relevant to the website that is subject to the client's request. The image URL attribute allows the client's website creation request to include a preferred image that can be used on the website as, for example, a featured image (e.g., on a banner, a header, etc.).
A theme attribute can also be included in the client's request to generate a website. A theme attribute includes a website theme according to which the generated website must be created. A theme can define formatting, styling, colors, fonts, layout, etc. for a website, and inclusion of a theme attribute allows for a user to make a theme selection so that the client's request can include that theme selection in the theme attribute. A theme can also define a general structure for a website. For example, a theme might define whether a website is a flat, scrollable single page of content or a series of interlinked pages. In some embodiments, the theme can be user-selected, but in the absence of a user selection, a default theme can instead be implemented and sent in the request. In some embodiments, if no theme attribute is included in the request, then the server uses a default theme.
In some embodiments, methods of the inventive subject matter can evaluate a variety of different aspects of items when determining a theme to represents those items. In these embodiments, item type or even aspects of various item representatives such as resolution, length of text, content of text, etc. can be taken into consideration when selecting a theme. For example, if a majority of items that are to be used in generating a website are images, then a theme that better represents images can be used. If titles and descriptions of items are long, then a theme can be selected that is better at representing text-heavy content (e.g., a theme where fonts are more legible and less stylized).
In some embodiments, some of the items to be used to generate a website are web pages. The domains from which those items originate can be evaluated and considered when determining an appropriate theme. For example, if the web pages to be included in a generated website predominantly originate from fashion websites, then a fashion-centered theme can be implemented for the generated website. If, on the other hand, the web pages to be included are predominantly news web pages, then a theme that is more appropriate for text-based information can be implemented for the generated website.
Next, the server generates a website in response to the client's request, as shown in step 706. The website that is generated, which can be accessed using a website URL (or other type of resource locator that facilitates access to the website over a network connection), comprises all items that have been added to the source folder.
Once the website has been generated, the server sends, to the client, a response to the website creation request, as shown in step 708. In some embodiments, actual website generation may alternatively occur when the website is requested by the user via http, https, or other website protocol. The response to the website creation request includes one, or any combination of the following: author attributes; an author identifier; an analytics ID; a created-at attribute; a data storage usage attribute; a description; a website image; a website name; the source folder identifier; total data storage usage; the website URL; and a visual completion status.
Author attributes can include an author name and an author avatar. In some embodiments, the author is the user that caused the client to send a website creation request to the server. Thus, the author name can be that user's name or username. The author avatar can be a user-defined image that is associated with the user or with the client. In some embodiments, the author and author avatar can both be user-defined.
An author identifier is used to identify the author of the website. In some embodiments, the author identifier is a token. The author identifier can be a UUID, or it can be an identifier that is unique within the server without being universally unique. The purpose of the author identifier is to allow the server to distinguish between authors of different websites that are generated in response to different website generation requests from different clients (i.e., requests from different authors).
An analytics ID can be included in some embodiments. The analytics ID can be, for example, an identifier that is specific to a website analytics aggregator (e.g., a Google Analytics ID). It can be useful in allowing an author (i.e., a user) to track data related to the generated website.
A created-at attribute includes one or both of a time and date at which the website was generated. It can additionally or alternatively include a date and time at which the response to the website generation request is sent to the client.
A data storage usage attribute includes information about the size of the generated website, which can be measured in bytes (e.g., kilo-, mega-, giga-). This information can be useful for optimization. For example, when a generated website exceeds a certain space threshold, the client can initiate a request to optimize the images on the generated website by changing the format or resolution of each image. This is important to reduce website loading times, which can often drive impatient users away from a website they are otherwise interested in visiting.
A description attribute is described above in more detail. In the response to the website generation request, the description attribute can include a description of the generated website, for example. In some embodiments, a description of a source folder can be the same as a description of a website that is generated using that source folder.
A website image attribute can include a featured image for the website. In some embodiments, the website image attribute can include information sufficient to describe several aspects of an image associated with the website. For example, the image attributes can include an array of information about an image including a full URL pointing to the original image or to an optimized version of the image, dimensions of the image, a URL pointing to a thumbnail of the image, and dimensions of the thumbnail of the image. In embodiments, a website image attribute can also include a focal point. The focal point defines the central point of interest for an image. When a focal point is defined, and the featured image is larger than the user's viewport (e.g., the user may be viewing the website on a mobile device), embodiments will avoid cropping the focal point out of the image.
A source folder identifier can also be included in the response. The source folder identifier identifies the source folder from which the website was created. It can be a UUID or an identifier that is unique within the server without being universally unique.
The response to the website creation request includes the website URL. The website URL can be used by, for example, a web browser to access the website that the server generated according to the client's request to generate a website from a source folder. The website URL can be used to directly access the generated website, or it can cause one or more re-directs resulting in accessing the generated website. Re-directs to access a generated website can be useful for website analytics including tracking where traffic to the generated website originates.
A visual completion status can also be included in the response to the website generation request. A visual completion status can indicate to a client whether the generated website's visual features have been completed. In some embodiments, a website's visual features are completed when all of the images on the website are optimized. Optimized images can be stored on the server that handles website generation or on another server for easy access by the generated website.
In some embodiments, the step of receiving a request to add an item to a source folder can comprise information sufficient to add multiple items to the source folder at the same time. For example, a user on a client computer could select some combination of either remotely stored items, locally stored items, or both, and information sufficient to identify and add those items to a source folder could be transmitted in the request according to the description above.
It is also contemplated that the step of receiving a request to add an item to a source folder can be carried out multiple times (e.g., in sequence or in parallel), where each request corresponds to a different item that a user on a client computer would like added to a source folder. The step of sending a response to the request to add an item to a source folder can be carried out once in response to multiple requests, or the server can generate a unique response to each request (e.g., each request corresponds to a single item and has a unique corresponding response).
The end result is that a source folder can hold any number of items, and when the server receives a request to generate a website, the server generates the website using all of the contents of the source folder. In some embodiments, a request to generate a website can also include instructions to include only a subset of items in the source folder.
In some embodiments, multiple source folders can be used to create a website. When multiple source folders are used in the course of generating a website, the server may use each source folder to create a different section on the website. For example, if a first source folder includes items related to chickens (e.g., articles, research papers, pictures) and a second source folder includes items related to eggs (e.g., articles, research papers, pictures), then the resulting website that the server generates using the first and second source folders would include two sections: a chicken section and an egg section. In the same or alternative embodiments, the server could generate a website where all the content from each source folder is combined into a single section of the website.
To create a website using multiple source folders, it is contemplated that the request to generate a website can identify multiple source folders by including multiple source folder identifiers. Then, when the server generates the website, it has sufficient information from the request to incorporate the contents of multiple source folders, and it can then incorporate sections into the website where each source folder corresponds to a section on the website.
In some embodiments, a source folder can additionally or alternatively include any number of subfolders. For example, a “chicken” source folder can include “domesticated chickens” and “chicken history” subfolders, where each subfolder can contain items. In these embodiments, the source folder itself can include one or more items as well as one or more subfolders. In embodiments where a source folder includes one or more subfolders, the request to generate a website includes, at a minimum, a source folder identifier for the main source folder that contains one or more subfolders. By identifying the source folder, the server can get information about all of the contents of the source folder, including information about items and subfolders contained in the source folder. It is also contemplated that the request to generate a website can include one or more source folder identifiers, where each source folder identifier corresponds to a source folder or subfolder (which can be considered a type of source folder).
As described above with relation to generating a website using multiple source folders, when a source folder includes subfolders, those subfolders can each be used by the server to create subsections on the generated website. For example, a main source folder can be a main section, and each subfolder within that source folder can be a subsection to the source folder's main section. This form of hierarchy can be repeated for any number of source folders and subfolders. It is contemplated that subfolders can themselves contain subfolders, and so on.
During the step of generating a website, the server can undertake several steps to create item representatives from the items in the one or more source folders used to create the website. For each item, the server can either create or identify one or more item representatives that can be used in the website. An item representative can be (or include), for example, an image, title, subtitle, and description pertaining to an item. In some embodiments, an item representative can also be (or include) a name and a title, as described above. In this way, one item can have one or more item representatives associated with it.
In some embodiments, the server can create the item representatives from the items in a source folder at the time the client sends a website creation request. In other embodiments, the server can create the item representatives at the time the items are added to the source folder, and then the server can use those item representatives when generating a website. In this case, the server can use the item representatives in both the source folder and the corresponding website.
In other embodiments, the server can create a shell of a website (i.e., a website that does not include any items) at the time the client sends a website creation request. Then, the server can dynamically create the item representatives at the time that a web browser requests that website from the server and fit the item representatives into the shell.
Item representatives can then be used by the server in the process of generating a website. For example, websites are generated, at least in part, according to a layout, where the layout includes guidelines about where item representatives (e.g., one or more parts of an item representative) for each item should be placed on the website, as well as how those item representatives should be styled (e.g., fonts, image cropping, location, orientation, border, and any other style information that can be applied using, for example, a CSS sheet). A layout can be included with a user-selected theme, or, if no user-selected theme is defined, a default layout (or, in some embodiments, a set of default layouts) is used.
With item representatives created for each item, generating a website then becomes a matter of fitting item representatives into corresponding places on the website according to the layout (e.g., placing an item description in an item description slot and fitting a corresponding item image in an item image slot that is positioned above the item description according to the layout).
Multiple layouts can also be used in the generation of a single website. For example, if a website includes multiple sections (e.g., a website is generated using items from multiple source folders, where each source folder is used for a different section of a generated website), then each section of the website can be generated according to a different layout. It is similarly contemplated that a single layout can be used for multiple sections of a generated website, causing each section to have a similar look and feel. As mentioned above, one or more layouts can be included in a theme.
Layouts facilitate visually pleasing presentations of item representatives by, for example helping to avoid undesirable image clipping and text truncation/clipping. Layouts also help to achieve variation and variety in the generated website's appearance. To further improve variety, embodiments may use one of several default layouts when a user does not define a layout (e.g., either by selecting a layout or by selecting a theme having one or more layouts). Layouts can help avoid dedicating a large space on a website for a low-resolution image that would not look good in that large space. Layouts can help to eliminate visual gaps on a generated website. Layouts can also be used to determine which item representatives would be appropriate for different areas of the website. For example, a layout can include a requirement that a text description item representative should be placed only if the text description includes fewer than 140 characters. In another example, a layout can require an image item representative to have a resolution that exceeds a certain threshold before it will display that image item representative in an image space on a generated website.
In some embodiments, layouts can include item slots that can be assessed and changed depending on the needs of the layout. Layouts that can bring about item slot changes to, for example, improve the visual appeal of a website or to eliminate gaps in a website's item slot arrangement can be referred to as auto-layouts. For example, if a layout includes a default item slot that accommodates both an item description and an accompanying item image, but an available item image has a resolution that is too low for the item slot's default configuration, then an auto-layout can cause the item slot to deviate from the default by, for example, changing the item slot to include a smaller image portion and to include a larger text description portion in response to the changed item image portion of the slot. Thus, an auto-layout of the inventive subject matter can, among other things, allow item slot configurations to depend on the item representatives to be shown in the item slots.
As mentioned above, a layout capable of adjusting item slots (e.g., changing size, shape, configuration, dimensions, etc.) is referred to as an “auto-layout.” An auto-layout is thus not necessarily constrained to a particular layout and can automatically adjust to accommodate different item representatives corresponding to items in a source folder. In the course of determining how an auto-layout needs to adjust to accommodate different item representatives, it is convenient to consider the subject matter that can be presented by a layout. Layouts can include both sections and item slots, where a section can contain other sections as well as item slots. Each section can itself include an image, a title, a description, or any combination thereof.
As discussed above, item slots can accommodate a wide variety of different item types (and item representatives created thereof), including links, notes, and uploads. Links can include web links, streaming video links (e.g., YouTube links), image links, document links, video links, and audio links. Uploads can include uploaded images, uploaded documents, uploaded video, and uploaded audio. Each item slot in a layout can include a representative image, a title, a subtitle, a description, etc. Additional information can also be included in the item slot, depending on the type of information contained in the corresponding item. For example, if the item includes video of any kind, then the item slot can include space for an item representative that includes a preview of the video (e.g., a looping portion of the video, a still from the video, or a still image that, upon hovering the mouse over it, shows segments of the video playing, etc.).
When a website is generated according to systems and methods of the inventive subject matter, an auto-layout (e.g., the server implementing an auto-layout) can determine whether each section within the layout should be formatted according to one of a plurality of section-level formats. For example, embodiments can include a “gallery” section and a “normal” or default section. Gallery sections present item slots that primarily feature images (e.g., thumbnails), as shown in
Auto-layouts can present images in a variety of ways. Images can be used as cover images (e.g., where the image covers an entire space of a section). In some embodiments, an image used as a cover image can be cropped or resized to better fit the area allocated for the cover image. Images can be placed into a container (e.g., an item slot), where the image can be shown uncropped but in a contained area and not shown fully edge to edge within that container. Images can also be presented as stamps, where a stamp is similar to an image container except that the stamp image is smaller (e.g., a thumbnail) than an ordinary container. In some embodiments, no image is used at all (e.g., other item representatives such as a description and title can be used without an associated image).
When a website is generated, the auto-layout is used to make a variety of determinations. It is used to determine several image options (e.g., whether the image should be shown, and, if it should be shown, whether it should be shown as a part of a cover, a container, or a stamp). Moreover, the auto-layout must also determine a configuration for each item slot within a layout, e.g., it must determine item slot sizes and whether each item slot should be split between, for example, an image and text, and how an image within an item slot should be presented (e.g., an image can be presented in any of the ways described above and shown in
In some embodiments, a layout (auto- or otherwise) can dictate that a generated website includes one or more columns for item slots. When a website includes two columns, for example, the item slots making up the two columns can be rearranged depending on screen size and resolution so that the content presented on the website can be dynamically changed to fit into a single column instead of two. This can be useful to ensure easy viewing when the website is accessed from devices with small screens (e.g., cell phones) and also from devices with larger screens (e.g., computers and laptops).
Item slots within layouts can be arranged in a variety of ways, including: single column width by single row height (“single”); double column width (“double wide”); double row height (“double high”); and double column width and double row height (“two by two”). For example, in a single item slot, the item slot can accommodate a variety of different item representatives including text overlaid on an image, text that is arranged side-by-side with an image, and text below an image within the single column width by single row height item slot. Double wide item slots can accommodate, for example, text overlaid on an image that spans the entire double wide item slot or an image with associated text beside it. A double high item slot can accommodate, for example, text overlaid on an image or text that is above or below an associated image. Two by two item slots can accommodate larger images, more text, or a combination of both with the option of including any other type of item representation.
When a layout includes double wide item slots, it is possible a gap can emerge in the layout. A gap, in this context, can appear when, for example, two double wide item slots 402, 404 (regardless of item height) appear above and below a one-column-wide item slot 406 (regardless of item slot height), as shown in
Gaps can also emerge when an item slot is placed next to another item slot where one of those two items slots has a different height than the other. For example, as shown in
An auto-layout of the inventive subject matter strives to achieve several goals. Auto-layouts can determine item slot dimensions and which item representatives should be placed within those item slots so as to improve information presentation. Auto-layouts help reduce, for example, image cropping and truncation of an item title or item description. For example, an item title can sometimes be truncated when it includes too much text in relation to the amount of space available in an item slot. An auto-layout can determine that an item having a longer associated title can be placed into either a double wide or double high item slot so there is more space for item representatives, including the longer title.
In another example, when an item slot has an aspect ratio that necessitates undesirable image cropping that can remove portions of an image that should not be removed (e.g., an image that has two people in it and one person is completely cropped out to accommodate an aspect ratio that is different from the image's natural aspect ratio), the auto-layout can change the item slot's dimensions to better accommodate the image. For example, tall item slots (e.g., item slots where the height is greater than the width) can lend themselves better to accommodating portrait-orientated images, whereas wide item slots (e.g., item slots having a greater width than height) can lend themselves to landscape-oriented images. In embodiments where an item slot is split (e.g., an item slot has an image item representative in one portion and a text item representative in another portion of the slot), the split between different item representatives in an item slot may be horizontal or vertical (e.g., depending on whether the item slot is wider than it is tall, or vice versa). It is also contemplated that the split can be diagonal, or the item slot can be split by a non-linear divider. An item slot's split can affect how item representatives within the item slot are cropped or truncated.
Auto-layouts can also help to bring about variation and variety in item slot choices. When the same item slots are repeated over and over again, a generated website can look dull. Accordingly, an auto-layout can randomly select different item slot sizes and configurations to help give a generated website the appearance of being human-made. In some embodiments, auto-layouts can also help to avoid allotting a large item slot or portion of an item slot for an image item representative if that image item representative includes an image that has too low of a resolution to look good within the allotted item slot. This helps avoid including low-quality images within layouts to give a generated website a more professional look.
In some embodiments, auto-layouts can also help reduce gaps by selecting item slot sizes that fit together without creating gaps. In some embodiments, the item slots selected for use within an auto-layout can be selected based on the content that needs to be included within those item slots. For example, images and videos can look better in item slots where the image or video can span the entire width of an item slot. When an item is a document, it can look better in an item slot where an image is separated from text (e.g., an item slot where there is a division between an image item representative and a text item representative). In some embodiments, an image associated with a document can itself be an image of a page in the document instead of an actual image from document (especially in cases where a document does not include any images). In these embodiments, having a text-based item representative overlaid on an image item representative from the document can make the text-based item representative impossible to read (e.g., because it would be laid over other text).
Webpages of the inventive subject matter are generated according to one or more layouts in phases. A layout, or auto-layout, can be used recursively during generation of each section of a generated website. In some embodiments, sections are considered independently of each other, while in other embodiments, sections can be interrelated such that relationships between sections can be taken into consideration during website generation.
For a given section to be generated in the course of generating a website, an auto-layout determines the different sizes and configurations of the item slots within the section. In some embodiments, the auto-layout can determine whether a section needs to show more than a cutoff number of items (e.g., more than five, more than 10, or more than 15). If items to be included within a section include media item types (e.g., audio, video, images, etc.), then the auto-layout can make the section into a gallery section. For example, an auto-layout creates a section as a gallery-type section when greater than some threshold quantity of image-type item representatives are to be fit into that section's item slots. In some embodiments, an auto-layout can set the section type to be gallery when the section includes >25%, >50%, or >75% image items. If the number of image items is less than a threshold amount, the section can be created normally.
In some embodiments, sections can be hybrid sections that include normal item slots and also gallery item slots. The gallery item slots can be grouped together. These embodiments do not require an all-or-nothing approach to section type determination, and thus it doesn't matter how many images there are in a given section—gallery item slots can be included in sufficient numbers to accommodate however many images exist within a section.
An auto-layout also determines what type of item slots can be used within a particular section. It selects the proper item slots for each item, e.g., it selects item slots having appropriate widths and heights as well as internal item slot configuration (see, e.g.,
An auto-layout can determine the best, or at least an acceptable, item slot size and configuration (i.e., the item slot type) according to a scoring algorithm. Particularly, for each item representative, the auto-layout can assign a numerical score to each possible item slot type. Item slot types with higher scores are selected over item slot types with lower scores for a particular item representative. Any or all of the attributes discussed herein, including item type, image resolution, title length, description length, etc. can increase or decrease the score of an item slot type based on its compatibility with an item representative. When two item slot types have the same score, an auto-layout can select one at random or one that has not been used recently to improve the variety of item slot types.
Item slot scores can be improved depending on an item slot's compatibility with one or both of an item's title length and description length. For example, items with short length titles and/or descriptions can be better suited for a single item slot with an image to a side of the title. Items with long length titles and/or descriptions, on the other hand, can be better suited for tall item slots (e.g., an item slot with greater height than width such as a double high item slot). Items with normal length titles and/or descriptions can be suited for all item slots except, for example, single and double item slots with edge-to-edge images and single item slots with an image on a side. Item title lengths can be evaluated according to standardized character lengths, e.g., a short title has at most 75 characters, a normal title can have from 75-115 characters, and a long title can have from 115-175 characters. Description title lengths can be evaluated similarly using corresponding ranges of characters.
Depending on item type, additional adjustments to item slot scores can also be made. For example, when an item is an image or a video, an auto-layout can ensure that the only item slots considered for those item types are configured to accommodate edge-to-edge image or video. In instances where an item is a document or note, on the other hand, an auto-layout can ensure that the only item slots for those item types are configured to include a split between an image and text.
In some embodiments, an item slot's score can be adjusted according to the nature of an image that is associated with an item. For example, if an image associated with an item is a screenshot of a web page or of the item itself (or believed to be a screenshot based on, e.g., a naming convention of the image file), the auto-layout can determine not to use an edge-to-edge item slot for that image. Often, edge-to-edge screenshots of a web page or an item can include text (e.g., when an item is a document or note, the only image for that item would be a screenshot of the document or note that includes text) and having an item's title or description overlaid on top of a screenshot of that text-laden item can result in text being overlaid onto text, making it difficult or impossible to read. In some embodiments, text can be detected in an item's image using, for example, OCR software, and when text is detected, an auto-layout can then determine that the affected item should not be placed into an item slot featuring an image overlaid with text.
In some embodiments, item slot scores can be affected by an aspect ratio or size of an item's image or video, or both. For example, an item slot's score can be improved when it's size or dimensions (or both) better match those of an item's image or video. Likewise, an item slot's score can be diminished when its size or dimensions (or both) do not match those of an item's image or video. For example, when an item representative (e.g., an item video or image) is approximately square, then the auto-layout can determine that an item slot should have a similar aspect ratio (e.g., the same number of columns and rows). When an item is a note or document, then the auto-layout can favor, for example, a single item slot, a double wide item slot where an item image is to a side of the slot, or a double high item slot with an image on the top or the bottom of the slot.
When an item to be included in an item slot is a web link, the auto-layout can give better scores to single item slots that accommodate an edge-to-edge image on a side of the slot, or an item slot that is taller than it is wide and having an image on the top or bottom.
In instances where an item image is around twice as wide as it is tall and also has sufficiently high resolution (where sufficiency of resolution can depend on a variety of factors including item slot size and resolution and size of a screen that it is to be presented on), a variety of item slots can be evaluated. For example, item slots that are configured to accommodate videos or images in an edge-to-edge manner, item slots for documents or notes that are wide with an image on a side, and item slots for web links that are wide with an edge-to-edge image can be considered baselines for scoring.
Item slots that are twice as wide as they are tall (e.g., double wide item slots) can receive better scores for images that are wider than they are tall (e.g., approximately twice as wide as tall). In instances where the image has a low resolution (e.g., a resolution where the image's low quality would be apparent when rendered on a website), then, for example, a single item slot with an image on top or bottom, a wide item slot (e.g., a double wide item slot) having an overlaid image, or a wide item slot with an image on a side can be given better scores than other item slots.
When an item image is elongated even more than a 2:1 ratio of width to height, then single item slots with the image on top can be scored better than other item slots. If an elongated image has a low resolution, then the score for an item slot that is wide with an image on a side can be reduced to make it less likely an auto-layout will select that item slot.
When an image is oriented as a portrait (e.g., taller than wide), then similar determinations are made as with elongated images, except that an auto-layout will favor single item slots with an image on a side, item slots that are taller than they are wide that accommodate an edge-to-edge image, or item slots that are wider than tall and accommodate an image on a side.
In some embodiments, in the course of selecting item slots, repetition of similar item slots can be avoided. For example, if an auto-layout evaluates an item slot for item n in a preliminary layout, the auto-layout will consider the configuration of item slots that have already been selected for items n-1 and n-2. If the same configuration of the item slot being considered for item n has already been selected for items n-1 or n-2, then an auto-layout can instead determine whether there exists an equal or comparable item slot (e.g., an item slot that scores equally or comparably to the item slot being considered for item n) that can be selected instead.
In some embodiments, auto-layout item slot selection, as mentioned above, can additionally consider image resolution of all images in a section. The auto-layout can then favor larger item slots (e.g., two by two item slots, double wide item slots, or double high item slots) for items having images with the highest resolutions (e.g., the top 5-20% of images) among the images in the section.
Once an item slot is selected, the auto-layout can set image options. For example, if an item image has a low resolution, then a stamp can be used. If an item is a document, then an image of the document (e.g., a screenshot of a page of the document) can be placed into a container to preserve aspect ratio, etc. If an item image is a screenshot, then the image can be put into a container for the same reasons a document's image would be placed into a container. In some embodiments, an image can be set as a cover image (e.g., with or without overlaid text), so that the image covers the full area allocated for the image, though the image may be cropped as a result.
As mentioned above, an auto-layout can also be responsible for filling gaps that are created when different sized item slots are placed adjacent to each other. In some embodiments, a preliminary layout of item slots is created. Adjacent combinations of item slots are evaluated to determine where gaps exist, and then the auto-layout determines how to fill those gaps by, for example, reorganizing or changing the dimensions of existing item slots. In some embodiments, item slot sizes and locations are determined before the website is generated so that by the time the website is generated, all item slots can fit together with minimal gaps (or, ideally, no gaps). In this sense, a preliminary layout can be created, and combinations of item slots are evaluated for gaps before modifying some of the item slots to eliminate those gaps. This process can be repeated until all gaps are eliminated, until any remaining gaps cannot be eliminated, or for some set maximum number of iterations (e.g., 5, 10, etc.)
In other embodiments, item slots are evaluated and modified sequentially, e.g., as each new item slot is considered and placed into an auto-layout, the auto-layout determines whether the item slot needs to be modified based on the other items slots that have already been placed. Decisions for gap elimination can thus be localized by section without necessitating a global view of an entire generated website. Thus, item slots can be evaluated either based on a preliminary arrangement of item slots, and, in some embodiments, the preliminary arrangement of item slots includes all possible item slots in preliminary positions before evaluation, while in other embodiments, a preliminary arrangement of item slots is generated one item slot at a time as each subsequent item slot is evaluated and put into position in the preliminary arrangement.
If a particular arrangement of item slots is found to result in a gap, then an auto-layout must determine how to eliminate the gap. For example, as shown in
In the example shown in
An auto-layout thus first identifies a gap and the arrangement of item slots that gave rise to the gap's existence. Next, it determines a best way to eliminate the gap. The “best way” to eliminate a gap takes several factors into consideration, including a frequency with which same-sized item slots are used in a section. For example, if too many item slots having the same size are used consecutively, then an item slot having that same size will be disfavored by the auto-layout for gap elimination. If a particular size of item slot is disfavored or otherwise cannot be used, then the remaining possible item slots are evaluated as discussed above. For example, if two possible item slot changes that can fill a gap are “make the item slot wide” or “make the item slot tall,” then the double high item slot change can be selected if the item includes a lot of text because double high item slots are better suited for more text.
Similarly, if a choice exists between taking a double high item slot and making it a single or a double wide item slot, then that item's image aspect ratio can be taken into consideration. For a landscape item image, for example, it can be better to change a double high item slot to a double wide item slot. It can also be desirable for an auto-layout to avoid side-by-side double high item slots (e.g., either where both double high item slots have similar internal arrangements of item representations or where the only similarity is that both item slots are in tall configurations). For example, when two double high item slots include edge-to-edge images or both have an image on top, it can reduce visual appeal. Thus, when an auto-layout considers how to eliminate a gap, it can evaluate aspect ratios of item images that will go into both item slots and take that into consideration so as to avoid item slot arrangements that are not visually appealing.
An auto-layout can also eliminate gaps by rearranging item slots (including corresponding items). For example, if a first row of a preliminary layout includes a double row height item slot next to a single row height item slot, and a second row below includes a single row height item slot next to a double row height item slot, the auto-layout can eliminate the gaps by swapping one of the single row height item slots with one of the double row height item slots.
Gap elimination, as discussed above, can be added into any system or method of the inventive subject matter disclosed in this application, including those shown in
In step 1002, the server generates at least one item representative for each item in the source folder. Again, this step is described above in more detail. Any method of the inventive subject matter that includes these steps can additionally include all of the following steps that are directed to gap elimination. In step 1004, the server determines, according to an auto-layout, a preliminary arrangement of item slots for the website. A preliminary arrangement refers to an item slot arrangement before any gaps have been eliminated.
In step 1006, the server determines whether any gaps exist in the preliminary arrangement. If any gaps exist, then at least one of those gaps is eliminated according to step 1008. Gap elimination can occur in any manner described in this application. Further, gap elimination can be undertaken recursively to minimize a number of gaps, thus steps 1006 and 1008 can be repeated after each time one or more gaps is eliminated from a layout.
Finally, in step 1010 the server generates the website and a website URL, and in step 1012 the server sends a website creation response to the client where the response includes the website URL that gives a user access to the website.
In embodiments, the server can generate a static website written in a markup language like HTML. In these embodiments, markup language labels in a corresponding document directly define the presentation of the website, including the size and positioning of the items, metadata, and sections. A web browser can then render the website as specified in the markup language document. In embodiments, the server can generate a programmatic website written in a scripting language like JavaScript. In these embodiments, one or more scripts can instruct the web browser to fetch the components of the website (i.e., the items, metadata, sections, etc.) and to render them in a particular way. A programmatic website can include myriad features such as responsive design, which formats the website for particular browsers, displays, and devices. A programmatic website, for example, can also permit users to interactively edit the website, including the items, metadata, and sections, within the website. In embodiments, the server can generate a website that includes both static and programmatic components. In embodiments, the terms “generate” and “regenerate” can refer to the creation of one or more website files (e.g., HTML files) that reside on disk, in memory, or in a database, and are later rendered by a web browser. In the same or alternative embodiments, these terms can refer to the creation of one or more objects in memory, in a database, or on disk that can later be retrieved and rendered by a web browser while executing scripting instructions.
In embodiments, the server can regenerate a website based on changes to the contents of the associated source folder (and any subfolders). For example, if a user adds new items to a source folder after the server has already generated a website, the server may regenerate the website to include the new items. Similarly, the server may regenerate the website if one or more existing items within the source folder have changed. For example, if a user changes the representative image or the title for an item, or deletes the item, the server may regenerate the website to reflect the changes. In embodiments, the client notifies the server when items are added to or changed within a source folder (and any subfolders), and the server automatically regenerates the website. Alternatively, the server may not regenerate the website until receiving an explicit instruction from the user to do so.
An embodiment of the inventive subject matter that incorporates some of the concepts above are shown in
In another embodiment shown in
In another step, the server receives a request from the client to generate a website, as shown in step 904. The request, which is analogous to the request described above with respect to
Finally, the server generates a website using the item representatives that the server generated based on the items in the source folder and its subfolders. The generated website includes up to as many sections as there are subfolders within the source folder, as shown in step 908.
Thus, specific systems and methods of generating websites have been disclosed. It should be apparent, however, to those skilled in the art that many more modifications besides those already described are possible without departing from the inventive concepts in this application. The inventive subject matter, therefore, is not to be restricted except in the spirit of the disclosure. Moreover, in interpreting the disclosure all terms should be interpreted in the broadest possible manner consistent with the context. In particular the terms “comprises” and “comprising” should be interpreted as referring to the elements, components, or steps in a non-exclusive manner, indicating that the referenced elements, components, or steps can be present, or utilized, or combined with other elements, components, or steps that are not expressly referenced.
This application is a continuation-in-part of and claims priority to U.S. patent application Ser. No. 16/118,289 filed Aug. 30, 2018.
| Number | Date | Country | |
|---|---|---|---|
| 20200151242 A1 | May 2020 | US |
| Number | Date | Country | |
|---|---|---|---|
| Parent | 16118289 | Aug 2018 | US |
| Child | 16371575 | US |
