blogit v1.2.1 Blogit.Components.Posts View Source
A Blogit.Component
process which can be queried from outside.
The Blogit.Components.Posts
process holds all the posts in the blog as its
state.
This process handles the following call
messages:
- :all -> returns all the posts of the blog as list of
Blogit.Models.Post
structures. - {:filter, filters, from, size} -> returns a list of posts sorted by their
meta.created_at field, newest first, filtered by the given
filters
and the firstfrom
are dropped. The size of the list is specified bysize
. The posts are represented byBlogit.Models.Post.Meta
structures so they can be presented in a stream by showing only their preview. - {:by_name, name} -> returns one post by its unique name. If there is no
post with the given
name
the tuple{:error, no-post-found-message}
is returned. If the post is present, the tuple{:ok, the-post}
is returned. The post is in the for of aBlogit.Models.Post
struct.
This component is supervised by Blogit.Components.Supervisor
and added to
it by Blogit.Server
.
When the posts get updated, this process’ state is updated by the
Blogit.Server
process.
The Blogit.Components.PostsByDate
and the Blogit.Components.Metas
processes calculate their state using this one.
Link to this section Summary
Functions
Returns the base name, which identifies the process. For example it
could be posts
Invoked when the server is started. start_link/3
or start/3
will
block until it returns
Returns the name, which identifies the process. It is composed using the
base_name/0
and the given language
. For example if the base_name/0
returns posts
and the given language is en
, the name will be
posts_en
Link to this section Functions
Returns the base name, which identifies the process. For example it
could be posts
.
Invoked when the server is started. start_link/3
or start/3
will
block until it returns.
args
is the argument term (second argument) passed to start_link/3
.
Returning {:ok, state}
will cause start_link/3
to return
{:ok, pid}
and the process to enter its loop.
Returning {:ok, state, timeout}
is similar to {:ok, state}
except handle_info(:timeout, state)
will be called after timeout
milliseconds if no messages are received within the timeout.
Returning {:ok, state, :hibernate}
is similar to
{:ok, state}
except the process is hibernated before entering the loop. See
c:handle_call/3
for more information on hibernation.
Returning :ignore
will cause start_link/3
to return :ignore
and the
process will exit normally without entering the loop or calling c:terminate/2
.
If used when part of a supervision tree the parent supervisor will not fail
to start nor immediately try to restart the GenServer
. The remainder of the
supervision tree will be (re)started and so the GenServer
should not be
required by other processes. It can be started later with
Supervisor.restart_child/2
as the child specification is saved in the parent
supervisor. The main use cases for this are:
- The
GenServer
is disabled by configuration but might be enabled later. - An error occurred and it will be handled by a different mechanism than the
Supervisor
. Likely this approach involves callingSupervisor.restart_child/2
after a delay to attempt a restart.
Returning {:stop, reason}
will cause start_link/3
to return
{:error, reason}
and the process to exit with reason reason
without
entering the loop or calling c:terminate/2
.
Callback implementation for GenServer.init/1
.
name(String.t) :: GenServer.on_start
name(String.t) :: atom
Returns the name, which identifies the process. It is composed using the
base_name/0
and the given language
. For example if the base_name/0
returns posts
and the given language is en
, the name will be
posts_en
.
The worker id registered under the Blogit.Components.Supervisor
will
be the name returned by this function, when start_link/1
is called
to create the process. The language passed to it
(or the one returned from Blogit.Settings.default_language/0
) will be
passed to name/1
to create the name.
Starts the GenServer
process.
The process is started and supervised by Blogit.Components.Supervisor
and the specification of it is added by Blogit.Server
.
The state of the process in the beginning is nil.
The process should keep the given language
passed to init/1
as the first of a tuple as part of its state. This process should serve
requests related to that language
.
The given state_provider
is the second element of the tuple passed to
GenServer.init/1
. It could be used to retrieve the state of
the process.
By default the language
is the one returned by
Blogit.Settings.default_language/0
and the state_provider
is
Blogit.Server
.