├── .circleci
    └── config.yml
├── .credo.exs
├── .env.example
├── .formatter.exs
├── .gitignore
├── .tool-versions
├── Dockerfile
├── LICENSE
├── README.md
├── assets
    ├── .stylelintrc.json
    ├── brunch-config.js
    ├── css
    │   ├── app.css
    │   └── syntax.css
    ├── js
    │   └── app.js
    ├── package.json
    ├── static
    │   ├── favicon.ico
    │   ├── images
    │   │   ├── dots-horizontal-triple.svg
    │   │   ├── globe.svg
    │   │   └── phoenix.png
    │   └── robots.txt
    ├── tailwind.js
    └── yarn.lock
├── bin
    ├── build
    ├── docker-build
    ├── release
    └── setup
├── config
    ├── config.exs
    ├── dev.exs
    ├── prod.exs
    └── test.exs
├── hooks
    └── pre-commit
├── lib
    ├── planet.ex
    ├── planet
    │   ├── application.ex
    │   ├── core
    │   │   ├── cron.ex
    │   │   ├── feed_fetcher.ex
    │   │   ├── feed_parser
    │   │   │   ├── atom.ex
    │   │   │   ├── entry.ex
    │   │   │   ├── feed.ex
    │   │   │   ├── feed_parser.ex
    │   │   │   ├── rss.ex
    │   │   │   └── sharepoint.ex
    │   │   ├── feed_server.ex
    │   │   ├── feed_store.ex
    │   │   ├── server_farm.ex
    │   │   └── server_farm_supervisor.ex
    │   ├── feeds
    │   │   ├── feeds.ex
    │   │   ├── planet.ex
    │   │   └── rss.ex
    │   ├── release_tasks.ex
    │   └── repo.ex
    ├── planet_web.ex
    └── planet_web
    │   ├── channels
    │       └── user_socket.ex
    │   ├── controllers
    │       ├── entries_controller.ex
    │       ├── planet_controller.ex
    │       └── rss_controller.ex
    │   ├── endpoint.ex
    │   ├── gettext.ex
    │   ├── router.ex
    │   ├── templates
    │       ├── entries
    │       │   └── index.html.eex
    │       ├── layout
    │       │   ├── _head.html.eex
    │       │   ├── _header.html.eex
    │       │   └── app.html.eex
    │       ├── planet
    │       │   ├── _form.html.eex
    │       │   └── edit.html.eex
    │       └── rss
    │       │   ├── _form.html.eex
    │       │   ├── edit.html.eex
    │       │   ├── feed.xml.eex
    │       │   ├── index.html.eex
    │       │   └── new.html.eex
    │   └── views
    │       ├── entries_view.ex
    │       ├── error_helpers.ex
    │       ├── error_view.ex
    │       ├── layout_view.ex
    │       ├── page_view.ex
    │       ├── planet_view.ex
    │       └── rss_view.ex
├── mix.exs
├── mix.lock
├── priv
    ├── gettext
    │   ├── en
    │   │   └── LC_MESSAGES
    │   │   │   └── errors.po
    │   └── errors.pot
    └── repo
    │   ├── migrations
    │       ├── 20180530015131_create_rss.exs
    │       ├── 20180728183311_add_sharepoint_column_to_rss_table.exs
    │       └── 20180922023130_create_planets.exs
    │   └── seeds.exs
├── rel
    ├── commands
    │   └── migrate.sh
    ├── config.exs
    └── plugins
    │   └── .gitignore
└── test
    ├── planet
        ├── core
        │   ├── cron_test.exs
        │   ├── feed_parser
        │   │   ├── feed_parser_test.exs
        │   │   └── feed_test.exs
        │   ├── feed_server_test.exs
        │   ├── server_farm_supervisor_test.exs
        │   └── server_farm_test.exs
        └── feeds
        │   └── feeds_test.exs
    ├── planet_web
        ├── controllers
        │   ├── planet_controller_test.exs
        │   └── rss_controller_test.exs
        ├── features
        │   ├── entries_feature_test.exs
        │   ├── planet_feature_test.exs
        │   └── rss_feature_test.exs
        └── views
        │   ├── error_view_test.exs
        │   ├── layout_view_test.exs
        │   └── page_view_test.exs
    ├── support
        ├── channel_case.ex
        ├── conn_case.ex
        ├── data_case.ex
        ├── feature_case.ex
        ├── mocks
        │   └── fetch_mock.ex
        └── support.ex
    └── test_helper.exs


/.circleci/config.yml:
--------------------------------------------------------------------------------
 1 | # Elixir CircleCI 2.0 configuration file
 2 | #
 3 | # Check https://circleci.com/docs/2.0/language-elixir/ for more details
 4 | version: 2
 5 | jobs:
 6 |   build:
 7 |     docker:
 8 |       - image: circleci/elixir:1.7-node-browsers
 9 |       - image: circleci/postgres:10.3
10 | 
11 |     working_directory: ~/repo
12 |     steps:
13 |       - checkout
14 |       - restore_cache:
15 |           keys:
16 |             - elixir-build-v3-{{ checksum "mix.lock" }}
17 | 
18 | 
19 |       - run: mix local.hex --force
20 |       - run: mix local.rebar --force
21 |       - run: mix deps.get
22 |       - run: mix ecto.create
23 | 
24 |       - run: cd assets && yarn
25 | 
26 |       - run: mix verify
27 | 
28 |       - save_cache:
29 |           key: elixir-build-v3-{{ checksum "mix.lock" }}
30 |           paths:
31 |             - '_build'
32 |             - 'deps'
33 |             - '~/.mix'
34 | 


--------------------------------------------------------------------------------
/.credo.exs:
--------------------------------------------------------------------------------
  1 | # This file contains the configuration for Credo and you are probably reading
  2 | # this after creating it with `mix credo.gen.config`.
  3 | #
  4 | # If you find anything wrong or unclear in this file, please report an
  5 | # issue on GitHub: https://github.com/rrrene/credo/issues
  6 | #
  7 | %{
  8 |   #
  9 |   # You can have as many configs as you like in the `configs:` field.
 10 |   configs: [
 11 |     %{
 12 |       #
 13 |       # Run any exec using `mix credo -C <name>`. If no exec name is given
 14 |       # "default" is used.
 15 |       #
 16 |       name: "default",
 17 |       #
 18 |       # These are the files included in the analysis:
 19 |       files: %{
 20 |         #
 21 |         # You can give explicit globs or simply directories.
 22 |         # In the latter case `**/*.{ex,exs}` will be used.
 23 |         #
 24 |         included: ["lib/", "test/"],
 25 |         excluded: [~r"/_build/", ~r"/deps/", ~r"/node_modules/"]
 26 |       },
 27 |       #
 28 |       # If you create your own checks, you must specify the source files for
 29 |       # them here, so they can be loaded by Credo before running the analysis.
 30 |       #
 31 |       requires: [],
 32 |       #
 33 |       # If you want to enforce a style guide and need a more traditional linting
 34 |       # experience, you can change `strict` to `true` below:
 35 |       #
 36 |       strict: true,
 37 |       #
 38 |       # If you want to use uncolored output by default, you can change `color`
 39 |       # to `false` below:
 40 |       #
 41 |       color: true,
 42 |       #
 43 |       # You can customize the parameters of any check by adding a second element
 44 |       # to the tuple.
 45 |       #
 46 |       # To disable a check put `false` as second element:
 47 |       #
 48 |       #     {Credo.Check.Design.DuplicatedCode, false}
 49 |       #
 50 |       checks: [
 51 |         #
 52 |         ## Consistency Checks
 53 |         #
 54 |         {Credo.Check.Consistency.ExceptionNames},
 55 |         {Credo.Check.Consistency.LineEndings},
 56 |         {Credo.Check.Consistency.ParameterPatternMatching},
 57 |         {Credo.Check.Consistency.SpaceAroundOperators},
 58 |         {Credo.Check.Consistency.SpaceInParentheses},
 59 |         {Credo.Check.Consistency.TabsOrSpaces},
 60 | 
 61 |         #
 62 |         ## Design Checks
 63 |         #
 64 |         # You can customize the priority of any check
 65 |         # Priority values are: `low, normal, high, higher`
 66 |         #
 67 |         {Credo.Check.Design.AliasUsage, false},
 68 |         # For some checks, you can also set other parameters
 69 |         #
 70 |         # If you don't want the `setup` and `test` macro calls in ExUnit tests
 71 |         # or the `schema` macro in Ecto schemas to trigger DuplicatedCode, just
 72 |         # set the `excluded_macros` parameter to `[:schema, :setup, :test]`.
 73 |         #
 74 |         {Credo.Check.Design.DuplicatedCode, excluded_macros: [:schema, :setup, :test]},
 75 |         # You can also customize the exit_status of each check.
 76 |         # If you don't want TODO comments to cause `mix credo` to fail, just
 77 |         # set this value to 0 (zero).
 78 |         #
 79 |         {Credo.Check.Design.TagTODO, exit_status: 2},
 80 |         {Credo.Check.Design.TagFIXME},
 81 | 
 82 |         #
 83 |         ## Readability Checks
 84 |         #
 85 |         {Credo.Check.Readability.AliasOrder},
 86 |         {Credo.Check.Readability.FunctionNames},
 87 |         {Credo.Check.Readability.LargeNumbers},
 88 |         {Credo.Check.Readability.MaxLineLength, priority: :low, max_length: 120},
 89 |         {Credo.Check.Readability.ModuleAttributeNames},
 90 |         {Credo.Check.Readability.ModuleDoc},
 91 |         {Credo.Check.Readability.ModuleNames},
 92 |         {Credo.Check.Readability.ParenthesesOnZeroArityDefs},
 93 |         {Credo.Check.Readability.ParenthesesInCondition},
 94 |         {Credo.Check.Readability.PredicateFunctionNames},
 95 |         {Credo.Check.Readability.PreferImplicitTry},
 96 |         {Credo.Check.Readability.RedundantBlankLines},
 97 |         {Credo.Check.Readability.StringSigils},
 98 |         {Credo.Check.Readability.TrailingBlankLine},
 99 |         {Credo.Check.Readability.TrailingWhiteSpace},
100 |         {Credo.Check.Readability.VariableNames},
101 |         {Credo.Check.Readability.Semicolons},
102 |         {Credo.Check.Readability.SpaceAfterCommas},
103 | 
104 |         #
105 |         ## Refactoring Opportunities
106 |         #
107 |         {Credo.Check.Refactor.DoubleBooleanNegation},
108 |         {Credo.Check.Refactor.CondStatements},
109 |         {Credo.Check.Refactor.CyclomaticComplexity},
110 |         {Credo.Check.Refactor.FunctionArity},
111 |         {Credo.Check.Refactor.LongQuoteBlocks},
112 |         {Credo.Check.Refactor.MapInto},
113 |         {Credo.Check.Refactor.MatchInCondition},
114 |         {Credo.Check.Refactor.NegatedConditionsInUnless},
115 |         {Credo.Check.Refactor.NegatedConditionsWithElse},
116 |         {Credo.Check.Refactor.Nesting},
117 |         {Credo.Check.Refactor.PipeChainStart,
118 |          excluded_argument_types: [:atom, :binary, :fn, :keyword], excluded_functions: []},
119 |         {Credo.Check.Refactor.UnlessWithElse},
120 | 
121 |         #
122 |         ## Warnings
123 |         #
124 |         {Credo.Check.Warning.BoolOperationOnSameValues},
125 |         {Credo.Check.Warning.ExpensiveEmptyEnumCheck},
126 |         {Credo.Check.Warning.IExPry},
127 |         {Credo.Check.Warning.IoInspect},
128 |         {Credo.Check.Warning.LazyLogging},
129 |         {Credo.Check.Warning.OperationOnSameValues},
130 |         {Credo.Check.Warning.OperationWithConstantResult},
131 |         {Credo.Check.Warning.UnusedEnumOperation},
132 |         {Credo.Check.Warning.UnusedFileOperation},
133 |         {Credo.Check.Warning.UnusedKeywordOperation},
134 |         {Credo.Check.Warning.UnusedListOperation},
135 |         {Credo.Check.Warning.UnusedPathOperation},
136 |         {Credo.Check.Warning.UnusedRegexOperation},
137 |         {Credo.Check.Warning.UnusedStringOperation},
138 |         {Credo.Check.Warning.UnusedTupleOperation},
139 |         {Credo.Check.Warning.RaiseInsideRescue},
140 | 
141 |         #
142 |         # Controversial and experimental checks (opt-in, just remove `, false`)
143 |         #
144 |         {Credo.Check.Refactor.ABCSize, false},
145 |         {Credo.Check.Refactor.AppendSingleItem, false},
146 |         {Credo.Check.Refactor.VariableRebinding, false},
147 |         {Credo.Check.Warning.MapGetUnsafePass, false},
148 |         {Credo.Check.Consistency.MultiAliasImportRequireUse, false},
149 | 
150 |         #
151 |         # Deprecated checks (these will be deleted after a grace period)
152 |         #
153 |         {Credo.Check.Readability.Specs, false}
154 | 
155 |         #
156 |         # Custom checks can be created using `mix credo.gen.check`.
157 |         #
158 |       ]
159 |     }
160 |   ]
161 | }
162 | 


--------------------------------------------------------------------------------
/.env.example:
--------------------------------------------------------------------------------
1 | SHAREPOINT_CREDS=username:password
2 | 


--------------------------------------------------------------------------------
/.formatter.exs:
--------------------------------------------------------------------------------
 1 | [
 2 |   inputs: ["mix.exs", "{config,rel,lib,test}/**/*.{ex,exs}"],
 3 |   locals_without_parens: [
 4 |     # Kernel
 5 |     inspect: 1,
 6 |     inspect: 2,
 7 | 
 8 |     # Phoenix
 9 |     plug: 1,
10 |     plug: 2,
11 |     action_fallback: 1,
12 |     render: 2,
13 |     render: 3,
14 |     render: 4,
15 |     redirect: 2,
16 |     socket: :*,
17 |     get: :*,
18 |     post: :*,
19 |     resources: :*,
20 |     pipe_through: :*,
21 |     delete: :*,
22 |     forward: :*,
23 |     channel: :*,
24 |     transport: :*,
25 | 
26 |     # Ecto Schema
27 |     field: 2,
28 |     field: 3,
29 |     belongs_to: 2,
30 |     belongs_to: 3,
31 |     has_one: 2,
32 |     has_one: 3,
33 |     has_many: 2,
34 |     has_many: 3,
35 |     embeds_one: 2,
36 |     embeds_one: 3,
37 |     embeds_many: 2,
38 |     embeds_many: 3,
39 |     many_to_many: 2,
40 |     many_to_many: 3,
41 |     add: :*,
42 |     remove: :*,
43 |     create: :*,
44 |     drop: :*,
45 | 
46 |     # Ecto Query
47 |     from: 2
48 |   ]
49 | ]
50 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # App artifacts
 2 | /_build
 3 | /db
 4 | /deps
 5 | /*.ez
 6 | 
 7 | # Generated on crash by the VM
 8 | erl_crash.dump
 9 | 
10 | # Generated on crash by NPM
11 | npm-debug.log
12 | 
13 | # Static artifacts
14 | /assets/node_modules
15 | /assets/static/feed.xml
16 | screenshots/
17 | /rel/artifacts
18 | /.hex
19 | /.mix
20 | 
21 | # Since we are building assets from assets/,
22 | # we ignore priv/static. You may want to comment
23 | # this depending on your deployment strategy.
24 | /priv/static/
25 | 
26 | # Files matching config/*.secret.exs pattern contain sensitive
27 | # data and you should not commit them into version control.
28 | #
29 | # Alternatively, you may comment the line below and commit the
30 | # secrets files as long as you replace their contents by environment
31 | # variables.
32 | /config/*.secret.exs
33 | .env
34 | 
35 | .DS_STORE
36 | 


--------------------------------------------------------------------------------
/.tool-versions:
--------------------------------------------------------------------------------
1 | elixir 1.7.3
2 | erlang 21.0.8
3 | nodejs 8.11.1
4 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM elixir:1.7.3
 2 | 
 3 | ENV REFRESHED_AT=2018-09-17 \
 4 |     HOME=/opt/build \
 5 |     TERM=xterm
 6 | 
 7 | WORKDIR /opt/build
 8 | 
 9 | RUN curl -sL https://deb.nodesource.com/setup_8.x | bash -
10 | RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
11 | RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
12 | RUN apt-get update -y 
13 | RUN apt-get install -y git locales nodejs yarn
14 | RUN locale-gen en_US.UTF-8
15 | 
16 | ENV LANG=en_US.UTF-8
17 | ENV LANGUAGE=en_US.UTF-8
18 | ENV LC_ALL=en_US.UTF-8
19 | 
20 | RUN elixir --version
21 | RUN node -v
22 | RUN yarn --version
23 | 
24 | CMD ["/bin/bash"]
25 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU AFFERO GENERAL PUBLIC LICENSE
  2 |                        Version 3, 19 November 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU Affero General Public License is a free, copyleft license for
 11 | software and other kinds of works, specifically designed to ensure
 12 | cooperation with the community in the case of network server software.
 13 | 
 14 |   The licenses for most software and other practical works are designed
 15 | to take away your freedom to share and change the works.  By contrast,
 16 | our General Public Licenses are intended to guarantee your freedom to
 17 | share and change all versions of a program--to make sure it remains free
 18 | software for all its users.
 19 | 
 20 |   When we speak of free software, we are referring to freedom, not
 21 | price.  Our General Public Licenses are designed to make sure that you
 22 | have the freedom to distribute copies of free software (and charge for
 23 | them if you wish), that you receive source code or can get it if you
 24 | want it, that you can change the software or use pieces of it in new
 25 | free programs, and that you know you can do these things.
 26 | 
 27 |   Developers that use our General Public Licenses protect your rights
 28 | with two steps: (1) assert copyright on the software, and (2) offer
 29 | you this License which gives you legal permission to copy, distribute
 30 | and/or modify the software.
 31 | 
 32 |   A secondary benefit of defending all users' freedom is that
 33 | improvements made in alternate versions of the program, if they
 34 | receive widespread use, become available for other developers to
 35 | incorporate.  Many developers of free software are heartened and
 36 | encouraged by the resulting cooperation.  However, in the case of
 37 | software used on network servers, this result may fail to come about.
 38 | The GNU General Public License permits making a modified version and
 39 | letting the public access it on a server without ever releasing its
 40 | source code to the public.
 41 | 
 42 |   The GNU Affero General Public License is designed specifically to
 43 | ensure that, in such cases, the modified source code becomes available
 44 | to the community.  It requires the operator of a network server to
 45 | provide the source code of the modified version running there to the
 46 | users of that server.  Therefore, public use of a modified version, on
 47 | a publicly accessible server, gives the public access to the source
 48 | code of the modified version.
 49 | 
 50 |   An older license, called the Affero General Public License and
 51 | published by Affero, was designed to accomplish similar goals.  This is
 52 | a different license, not a version of the Affero GPL, but Affero has
 53 | released a new version of the Affero GPL which permits relicensing under
 54 | this license.
 55 | 
 56 |   The precise terms and conditions for copying, distribution and
 57 | modification follow.
 58 | 
 59 |                        TERMS AND CONDITIONS
 60 | 
 61 |   0. Definitions.
 62 | 
 63 |   "This License" refers to version 3 of the GNU Affero General Public License.
 64 | 
 65 |   "Copyright" also means copyright-like laws that apply to other kinds of
 66 | works, such as semiconductor masks.
 67 | 
 68 |   "The Program" refers to any copyrightable work licensed under this
 69 | License.  Each licensee is addressed as "you".  "Licensees" and
 70 | "recipients" may be individuals or organizations.
 71 | 
 72 |   To "modify" a work means to copy from or adapt all or part of the work
 73 | in a fashion requiring copyright permission, other than the making of an
 74 | exact copy.  The resulting work is called a "modified version" of the
 75 | earlier work or a work "based on" the earlier work.
 76 | 
 77 |   A "covered work" means either the unmodified Program or a work based
 78 | on the Program.
 79 | 
 80 |   To "propagate" a work means to do anything with it that, without
 81 | permission, would make you directly or secondarily liable for
 82 | infringement under applicable copyright law, except executing it on a
 83 | computer or modifying a private copy.  Propagation includes copying,
 84 | distribution (with or without modification), making available to the
 85 | public, and in some countries other activities as well.
 86 | 
 87 |   To "convey" a work means any kind of propagation that enables other
 88 | parties to make or receive copies.  Mere interaction with a user through
 89 | a computer network, with no transfer of a copy, is not conveying.
 90 | 
 91 |   An interactive user interface displays "Appropriate Legal Notices"
 92 | to the extent that it includes a convenient and prominently visible
 93 | feature that (1) displays an appropriate copyright notice, and (2)
 94 | tells the user that there is no warranty for the work (except to the
 95 | extent that warranties are provided), that licensees may convey the
 96 | work under this License, and how to view a copy of this License.  If
 97 | the interface presents a list of user commands or options, such as a
 98 | menu, a prominent item in the list meets this criterion.
 99 | 
100 |   1. Source Code.
101 | 
102 |   The "source code" for a work means the preferred form of the work
103 | for making modifications to it.  "Object code" means any non-source
104 | form of a work.
105 | 
106 |   A "Standard Interface" means an interface that either is an official
107 | standard defined by a recognized standards body, or, in the case of
108 | interfaces specified for a particular programming language, one that
109 | is widely used among developers working in that language.
110 | 
111 |   The "System Libraries" of an executable work include anything, other
112 | than the work as a whole, that (a) is included in the normal form of
113 | packaging a Major Component, but which is not part of that Major
114 | Component, and (b) serves only to enable use of the work with that
115 | Major Component, or to implement a Standard Interface for which an
116 | implementation is available to the public in source code form.  A
117 | "Major Component", in this context, means a major essential component
118 | (kernel, window system, and so on) of the specific operating system
119 | (if any) on which the executable work runs, or a compiler used to
120 | produce the work, or an object code interpreter used to run it.
121 | 
122 |   The "Corresponding Source" for a work in object code form means all
123 | the source code needed to generate, install, and (for an executable
124 | work) run the object code and to modify the work, including scripts to
125 | control those activities.  However, it does not include the work's
126 | System Libraries, or general-purpose tools or generally available free
127 | programs which are used unmodified in performing those activities but
128 | which are not part of the work.  For example, Corresponding Source
129 | includes interface definition files associated with source files for
130 | the work, and the source code for shared libraries and dynamically
131 | linked subprograms that the work is specifically designed to require,
132 | such as by intimate data communication or control flow between those
133 | subprograms and other parts of the work.
134 | 
135 |   The Corresponding Source need not include anything that users
136 | can regenerate automatically from other parts of the Corresponding
137 | Source.
138 | 
139 |   The Corresponding Source for a work in source code form is that
140 | same work.
141 | 
142 |   2. Basic Permissions.
143 | 
144 |   All rights granted under this License are granted for the term of
145 | copyright on the Program, and are irrevocable provided the stated
146 | conditions are met.  This License explicitly affirms your unlimited
147 | permission to run the unmodified Program.  The output from running a
148 | covered work is covered by this License only if the output, given its
149 | content, constitutes a covered work.  This License acknowledges your
150 | rights of fair use or other equivalent, as provided by copyright law.
151 | 
152 |   You may make, run and propagate covered works that you do not
153 | convey, without conditions so long as your license otherwise remains
154 | in force.  You may convey covered works to others for the sole purpose
155 | of having them make modifications exclusively for you, or provide you
156 | with facilities for running those works, provided that you comply with
157 | the terms of this License in conveying all material for which you do
158 | not control copyright.  Those thus making or running the covered works
159 | for you must do so exclusively on your behalf, under your direction
160 | and control, on terms that prohibit them from making any copies of
161 | your copyrighted material outside their relationship with you.
162 | 
163 |   Conveying under any other circumstances is permitted solely under
164 | the conditions stated below.  Sublicensing is not allowed; section 10
165 | makes it unnecessary.
166 | 
167 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
168 | 
169 |   No covered work shall be deemed part of an effective technological
170 | measure under any applicable law fulfilling obligations under article
171 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
172 | similar laws prohibiting or restricting circumvention of such
173 | measures.
174 | 
175 |   When you convey a covered work, you waive any legal power to forbid
176 | circumvention of technological measures to the extent such circumvention
177 | is effected by exercising rights under this License with respect to
178 | the covered work, and you disclaim any intention to limit operation or
179 | modification of the work as a means of enforcing, against the work's
180 | users, your or third parties' legal rights to forbid circumvention of
181 | technological measures.
182 | 
183 |   4. Conveying Verbatim Copies.
184 | 
185 |   You may convey verbatim copies of the Program's source code as you
186 | receive it, in any medium, provided that you conspicuously and
187 | appropriately publish on each copy an appropriate copyright notice;
188 | keep intact all notices stating that this License and any
189 | non-permissive terms added in accord with section 7 apply to the code;
190 | keep intact all notices of the absence of any warranty; and give all
191 | recipients a copy of this License along with the Program.
192 | 
193 |   You may charge any price or no price for each copy that you convey,
194 | and you may offer support or warranty protection for a fee.
195 | 
196 |   5. Conveying Modified Source Versions.
197 | 
198 |   You may convey a work based on the Program, or the modifications to
199 | produce it from the Program, in the form of source code under the
200 | terms of section 4, provided that you also meet all of these conditions:
201 | 
202 |     a) The work must carry prominent notices stating that you modified
203 |     it, and giving a relevant date.
204 | 
205 |     b) The work must carry prominent notices stating that it is
206 |     released under this License and any conditions added under section
207 |     7.  This requirement modifies the requirement in section 4 to
208 |     "keep intact all notices".
209 | 
210 |     c) You must license the entire work, as a whole, under this
211 |     License to anyone who comes into possession of a copy.  This
212 |     License will therefore apply, along with any applicable section 7
213 |     additional terms, to the whole of the work, and all its parts,
214 |     regardless of how they are packaged.  This License gives no
215 |     permission to license the work in any other way, but it does not
216 |     invalidate such permission if you have separately received it.
217 | 
218 |     d) If the work has interactive user interfaces, each must display
219 |     Appropriate Legal Notices; however, if the Program has interactive
220 |     interfaces that do not display Appropriate Legal Notices, your
221 |     work need not make them do so.
222 | 
223 |   A compilation of a covered work with other separate and independent
224 | works, which are not by their nature extensions of the covered work,
225 | and which are not combined with it such as to form a larger program,
226 | in or on a volume of a storage or distribution medium, is called an
227 | "aggregate" if the compilation and its resulting copyright are not
228 | used to limit the access or legal rights of the compilation's users
229 | beyond what the individual works permit.  Inclusion of a covered work
230 | in an aggregate does not cause this License to apply to the other
231 | parts of the aggregate.
232 | 
233 |   6. Conveying Non-Source Forms.
234 | 
235 |   You may convey a covered work in object code form under the terms
236 | of sections 4 and 5, provided that you also convey the
237 | machine-readable Corresponding Source under the terms of this License,
238 | in one of these ways:
239 | 
240 |     a) Convey the object code in, or embodied in, a physical product
241 |     (including a physical distribution medium), accompanied by the
242 |     Corresponding Source fixed on a durable physical medium
243 |     customarily used for software interchange.
244 | 
245 |     b) Convey the object code in, or embodied in, a physical product
246 |     (including a physical distribution medium), accompanied by a
247 |     written offer, valid for at least three years and valid for as
248 |     long as you offer spare parts or customer support for that product
249 |     model, to give anyone who possesses the object code either (1) a
250 |     copy of the Corresponding Source for all the software in the
251 |     product that is covered by this License, on a durable physical
252 |     medium customarily used for software interchange, for a price no
253 |     more than your reasonable cost of physically performing this
254 |     conveying of source, or (2) access to copy the
255 |     Corresponding Source from a network server at no charge.
256 | 
257 |     c) Convey individual copies of the object code with a copy of the
258 |     written offer to provide the Corresponding Source.  This
259 |     alternative is allowed only occasionally and noncommercially, and
260 |     only if you received the object code with such an offer, in accord
261 |     with subsection 6b.
262 | 
263 |     d) Convey the object code by offering access from a designated
264 |     place (gratis or for a charge), and offer equivalent access to the
265 |     Corresponding Source in the same way through the same place at no
266 |     further charge.  You need not require recipients to copy the
267 |     Corresponding Source along with the object code.  If the place to
268 |     copy the object code is a network server, the Corresponding Source
269 |     may be on a different server (operated by you or a third party)
270 |     that supports equivalent copying facilities, provided you maintain
271 |     clear directions next to the object code saying where to find the
272 |     Corresponding Source.  Regardless of what server hosts the
273 |     Corresponding Source, you remain obligated to ensure that it is
274 |     available for as long as needed to satisfy these requirements.
275 | 
276 |     e) Convey the object code using peer-to-peer transmission, provided
277 |     you inform other peers where the object code and Corresponding
278 |     Source of the work are being offered to the general public at no
279 |     charge under subsection 6d.
280 | 
281 |   A separable portion of the object code, whose source code is excluded
282 | from the Corresponding Source as a System Library, need not be
283 | included in conveying the object code work.
284 | 
285 |   A "User Product" is either (1) a "consumer product", which means any
286 | tangible personal property which is normally used for personal, family,
287 | or household purposes, or (2) anything designed or sold for incorporation
288 | into a dwelling.  In determining whether a product is a consumer product,
289 | doubtful cases shall be resolved in favor of coverage.  For a particular
290 | product received by a particular user, "normally used" refers to a
291 | typical or common use of that class of product, regardless of the status
292 | of the particular user or of the way in which the particular user
293 | actually uses, or expects or is expected to use, the product.  A product
294 | is a consumer product regardless of whether the product has substantial
295 | commercial, industrial or non-consumer uses, unless such uses represent
296 | the only significant mode of use of the product.
297 | 
298 |   "Installation Information" for a User Product means any methods,
299 | procedures, authorization keys, or other information required to install
300 | and execute modified versions of a covered work in that User Product from
301 | a modified version of its Corresponding Source.  The information must
302 | suffice to ensure that the continued functioning of the modified object
303 | code is in no case prevented or interfered with solely because
304 | modification has been made.
305 | 
306 |   If you convey an object code work under this section in, or with, or
307 | specifically for use in, a User Product, and the conveying occurs as
308 | part of a transaction in which the right of possession and use of the
309 | User Product is transferred to the recipient in perpetuity or for a
310 | fixed term (regardless of how the transaction is characterized), the
311 | Corresponding Source conveyed under this section must be accompanied
312 | by the Installation Information.  But this requirement does not apply
313 | if neither you nor any third party retains the ability to install
314 | modified object code on the User Product (for example, the work has
315 | been installed in ROM).
316 | 
317 |   The requirement to provide Installation Information does not include a
318 | requirement to continue to provide support service, warranty, or updates
319 | for a work that has been modified or installed by the recipient, or for
320 | the User Product in which it has been modified or installed.  Access to a
321 | network may be denied when the modification itself materially and
322 | adversely affects the operation of the network or violates the rules and
323 | protocols for communication across the network.
324 | 
325 |   Corresponding Source conveyed, and Installation Information provided,
326 | in accord with this section must be in a format that is publicly
327 | documented (and with an implementation available to the public in
328 | source code form), and must require no special password or key for
329 | unpacking, reading or copying.
330 | 
331 |   7. Additional Terms.
332 | 
333 |   "Additional permissions" are terms that supplement the terms of this
334 | License by making exceptions from one or more of its conditions.
335 | Additional permissions that are applicable to the entire Program shall
336 | be treated as though they were included in this License, to the extent
337 | that they are valid under applicable law.  If additional permissions
338 | apply only to part of the Program, that part may be used separately
339 | under those permissions, but the entire Program remains governed by
340 | this License without regard to the additional permissions.
341 | 
342 |   When you convey a copy of a covered work, you may at your option
343 | remove any additional permissions from that copy, or from any part of
344 | it.  (Additional permissions may be written to require their own
345 | removal in certain cases when you modify the work.)  You may place
346 | additional permissions on material, added by you to a covered work,
347 | for which you have or can give appropriate copyright permission.
348 | 
349 |   Notwithstanding any other provision of this License, for material you
350 | add to a covered work, you may (if authorized by the copyright holders of
351 | that material) supplement the terms of this License with terms:
352 | 
353 |     a) Disclaiming warranty or limiting liability differently from the
354 |     terms of sections 15 and 16 of this License; or
355 | 
356 |     b) Requiring preservation of specified reasonable legal notices or
357 |     author attributions in that material or in the Appropriate Legal
358 |     Notices displayed by works containing it; or
359 | 
360 |     c) Prohibiting misrepresentation of the origin of that material, or
361 |     requiring that modified versions of such material be marked in
362 |     reasonable ways as different from the original version; or
363 | 
364 |     d) Limiting the use for publicity purposes of names of licensors or
365 |     authors of the material; or
366 | 
367 |     e) Declining to grant rights under trademark law for use of some
368 |     trade names, trademarks, or service marks; or
369 | 
370 |     f) Requiring indemnification of licensors and authors of that
371 |     material by anyone who conveys the material (or modified versions of
372 |     it) with contractual assumptions of liability to the recipient, for
373 |     any liability that these contractual assumptions directly impose on
374 |     those licensors and authors.
375 | 
376 |   All other non-permissive additional terms are considered "further
377 | restrictions" within the meaning of section 10.  If the Program as you
378 | received it, or any part of it, contains a notice stating that it is
379 | governed by this License along with a term that is a further
380 | restriction, you may remove that term.  If a license document contains
381 | a further restriction but permits relicensing or conveying under this
382 | License, you may add to a covered work material governed by the terms
383 | of that license document, provided that the further restriction does
384 | not survive such relicensing or conveying.
385 | 
386 |   If you add terms to a covered work in accord with this section, you
387 | must place, in the relevant source files, a statement of the
388 | additional terms that apply to those files, or a notice indicating
389 | where to find the applicable terms.
390 | 
391 |   Additional terms, permissive or non-permissive, may be stated in the
392 | form of a separately written license, or stated as exceptions;
393 | the above requirements apply either way.
394 | 
395 |   8. Termination.
396 | 
397 |   You may not propagate or modify a covered work except as expressly
398 | provided under this License.  Any attempt otherwise to propagate or
399 | modify it is void, and will automatically terminate your rights under
400 | this License (including any patent licenses granted under the third
401 | paragraph of section 11).
402 | 
403 |   However, if you cease all violation of this License, then your
404 | license from a particular copyright holder is reinstated (a)
405 | provisionally, unless and until the copyright holder explicitly and
406 | finally terminates your license, and (b) permanently, if the copyright
407 | holder fails to notify you of the violation by some reasonable means
408 | prior to 60 days after the cessation.
409 | 
410 |   Moreover, your license from a particular copyright holder is
411 | reinstated permanently if the copyright holder notifies you of the
412 | violation by some reasonable means, this is the first time you have
413 | received notice of violation of this License (for any work) from that
414 | copyright holder, and you cure the violation prior to 30 days after
415 | your receipt of the notice.
416 | 
417 |   Termination of your rights under this section does not terminate the
418 | licenses of parties who have received copies or rights from you under
419 | this License.  If your rights have been terminated and not permanently
420 | reinstated, you do not qualify to receive new licenses for the same
421 | material under section 10.
422 | 
423 |   9. Acceptance Not Required for Having Copies.
424 | 
425 |   You are not required to accept this License in order to receive or
426 | run a copy of the Program.  Ancillary propagation of a covered work
427 | occurring solely as a consequence of using peer-to-peer transmission
428 | to receive a copy likewise does not require acceptance.  However,
429 | nothing other than this License grants you permission to propagate or
430 | modify any covered work.  These actions infringe copyright if you do
431 | not accept this License.  Therefore, by modifying or propagating a
432 | covered work, you indicate your acceptance of this License to do so.
433 | 
434 |   10. Automatic Licensing of Downstream Recipients.
435 | 
436 |   Each time you convey a covered work, the recipient automatically
437 | receives a license from the original licensors, to run, modify and
438 | propagate that work, subject to this License.  You are not responsible
439 | for enforcing compliance by third parties with this License.
440 | 
441 |   An "entity transaction" is a transaction transferring control of an
442 | organization, or substantially all assets of one, or subdividing an
443 | organization, or merging organizations.  If propagation of a covered
444 | work results from an entity transaction, each party to that
445 | transaction who receives a copy of the work also receives whatever
446 | licenses to the work the party's predecessor in interest had or could
447 | give under the previous paragraph, plus a right to possession of the
448 | Corresponding Source of the work from the predecessor in interest, if
449 | the predecessor has it or can get it with reasonable efforts.
450 | 
451 |   You may not impose any further restrictions on the exercise of the
452 | rights granted or affirmed under this License.  For example, you may
453 | not impose a license fee, royalty, or other charge for exercise of
454 | rights granted under this License, and you may not initiate litigation
455 | (including a cross-claim or counterclaim in a lawsuit) alleging that
456 | any patent claim is infringed by making, using, selling, offering for
457 | sale, or importing the Program or any portion of it.
458 | 
459 |   11. Patents.
460 | 
461 |   A "contributor" is a copyright holder who authorizes use under this
462 | License of the Program or a work on which the Program is based.  The
463 | work thus licensed is called the contributor's "contributor version".
464 | 
465 |   A contributor's "essential patent claims" are all patent claims
466 | owned or controlled by the contributor, whether already acquired or
467 | hereafter acquired, that would be infringed by some manner, permitted
468 | by this License, of making, using, or selling its contributor version,
469 | but do not include claims that would be infringed only as a
470 | consequence of further modification of the contributor version.  For
471 | purposes of this definition, "control" includes the right to grant
472 | patent sublicenses in a manner consistent with the requirements of
473 | this License.
474 | 
475 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
476 | patent license under the contributor's essential patent claims, to
477 | make, use, sell, offer for sale, import and otherwise run, modify and
478 | propagate the contents of its contributor version.
479 | 
480 |   In the following three paragraphs, a "patent license" is any express
481 | agreement or commitment, however denominated, not to enforce a patent
482 | (such as an express permission to practice a patent or covenant not to
483 | sue for patent infringement).  To "grant" such a patent license to a
484 | party means to make such an agreement or commitment not to enforce a
485 | patent against the party.
486 | 
487 |   If you convey a covered work, knowingly relying on a patent license,
488 | and the Corresponding Source of the work is not available for anyone
489 | to copy, free of charge and under the terms of this License, through a
490 | publicly available network server or other readily accessible means,
491 | then you must either (1) cause the Corresponding Source to be so
492 | available, or (2) arrange to deprive yourself of the benefit of the
493 | patent license for this particular work, or (3) arrange, in a manner
494 | consistent with the requirements of this License, to extend the patent
495 | license to downstream recipients.  "Knowingly relying" means you have
496 | actual knowledge that, but for the patent license, your conveying the
497 | covered work in a country, or your recipient's use of the covered work
498 | in a country, would infringe one or more identifiable patents in that
499 | country that you have reason to believe are valid.
500 | 
501 |   If, pursuant to or in connection with a single transaction or
502 | arrangement, you convey, or propagate by procuring conveyance of, a
503 | covered work, and grant a patent license to some of the parties
504 | receiving the covered work authorizing them to use, propagate, modify
505 | or convey a specific copy of the covered work, then the patent license
506 | you grant is automatically extended to all recipients of the covered
507 | work and works based on it.
508 | 
509 |   A patent license is "discriminatory" if it does not include within
510 | the scope of its coverage, prohibits the exercise of, or is
511 | conditioned on the non-exercise of one or more of the rights that are
512 | specifically granted under this License.  You may not convey a covered
513 | work if you are a party to an arrangement with a third party that is
514 | in the business of distributing software, under which you make payment
515 | to the third party based on the extent of your activity of conveying
516 | the work, and under which the third party grants, to any of the
517 | parties who would receive the covered work from you, a discriminatory
518 | patent license (a) in connection with copies of the covered work
519 | conveyed by you (or copies made from those copies), or (b) primarily
520 | for and in connection with specific products or compilations that
521 | contain the covered work, unless you entered into that arrangement,
522 | or that patent license was granted, prior to 28 March 2007.
523 | 
524 |   Nothing in this License shall be construed as excluding or limiting
525 | any implied license or other defenses to infringement that may
526 | otherwise be available to you under applicable patent law.
527 | 
528 |   12. No Surrender of Others' Freedom.
529 | 
530 |   If conditions are imposed on you (whether by court order, agreement or
531 | otherwise) that contradict the conditions of this License, they do not
532 | excuse you from the conditions of this License.  If you cannot convey a
533 | covered work so as to satisfy simultaneously your obligations under this
534 | License and any other pertinent obligations, then as a consequence you may
535 | not convey it at all.  For example, if you agree to terms that obligate you
536 | to collect a royalty for further conveying from those to whom you convey
537 | the Program, the only way you could satisfy both those terms and this
538 | License would be to refrain entirely from conveying the Program.
539 | 
540 |   13. Remote Network Interaction; Use with the GNU General Public License.
541 | 
542 |   Notwithstanding any other provision of this License, if you modify the
543 | Program, your modified version must prominently offer all users
544 | interacting with it remotely through a computer network (if your version
545 | supports such interaction) an opportunity to receive the Corresponding
546 | Source of your version by providing access to the Corresponding Source
547 | from a network server at no charge, through some standard or customary
548 | means of facilitating copying of software.  This Corresponding Source
549 | shall include the Corresponding Source for any work covered by version 3
550 | of the GNU General Public License that is incorporated pursuant to the
551 | following paragraph.
552 | 
553 |   Notwithstanding any other provision of this License, you have
554 | permission to link or combine any covered work with a work licensed
555 | under version 3 of the GNU General Public License into a single
556 | combined work, and to convey the resulting work.  The terms of this
557 | License will continue to apply to the part which is the covered work,
558 | but the work with which it is combined will remain governed by version
559 | 3 of the GNU General Public License.
560 | 
561 |   14. Revised Versions of this License.
562 | 
563 |   The Free Software Foundation may publish revised and/or new versions of
564 | the GNU Affero General Public License from time to time.  Such new versions
565 | will be similar in spirit to the present version, but may differ in detail to
566 | address new problems or concerns.
567 | 
568 |   Each version is given a distinguishing version number.  If the
569 | Program specifies that a certain numbered version of the GNU Affero General
570 | Public License "or any later version" applies to it, you have the
571 | option of following the terms and conditions either of that numbered
572 | version or of any later version published by the Free Software
573 | Foundation.  If the Program does not specify a version number of the
574 | GNU Affero General Public License, you may choose any version ever published
575 | by the Free Software Foundation.
576 | 
577 |   If the Program specifies that a proxy can decide which future
578 | versions of the GNU Affero General Public License can be used, that proxy's
579 | public statement of acceptance of a version permanently authorizes you
580 | to choose that version for the Program.
581 | 
582 |   Later license versions may give you additional or different
583 | permissions.  However, no additional obligations are imposed on any
584 | author or copyright holder as a result of your choosing to follow a
585 | later version.
586 | 
587 |   15. Disclaimer of Warranty.
588 | 
589 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
590 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
591 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
592 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
593 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
594 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
595 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
596 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
597 | 
598 |   16. Limitation of Liability.
599 | 
600 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
601 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
602 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
603 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
604 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
605 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
606 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
607 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
608 | SUCH DAMAGES.
609 | 
610 |   17. Interpretation of Sections 15 and 16.
611 | 
612 |   If the disclaimer of warranty and limitation of liability provided
613 | above cannot be given local legal effect according to their terms,
614 | reviewing courts shall apply local law that most closely approximates
615 | an absolute waiver of all civil liability in connection with the
616 | Program, unless a warranty or assumption of liability accompanies a
617 | copy of the Program in return for a fee.
618 | 
619 |                      END OF TERMS AND CONDITIONS
620 | 
621 |             How to Apply These Terms to Your New Programs
622 | 
623 |   If you develop a new program, and you want it to be of the greatest
624 | possible use to the public, the best way to achieve this is to make it
625 | free software which everyone can redistribute and change under these terms.
626 | 
627 |   To do so, attach the following notices to the program.  It is safest
628 | to attach them to the start of each source file to most effectively
629 | state the exclusion of warranty; and each file should have at least
630 | the "copyright" line and a pointer to where the full notice is found.
631 | 
632 |     <one line to give the program's name and a brief idea of what it does.>
633 |     Copyright (C) <year>  <name of author>
634 | 
635 |     This program is free software: you can redistribute it and/or modify
636 |     it under the terms of the GNU Affero General Public License as published
637 |     by the Free Software Foundation, either version 3 of the License, or
638 |     (at your option) any later version.
639 | 
640 |     This program is distributed in the hope that it will be useful,
641 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
642 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
643 |     GNU Affero General Public License for more details.
644 | 
645 |     You should have received a copy of the GNU Affero General Public License
646 |     along with this program.  If not, see <http://www.gnu.org/licenses/>.
647 | 
648 | Also add information on how to contact you by electronic and paper mail.
649 | 
650 |   If your software can interact with users remotely through a computer
651 | network, you should also make sure that it provides a way for users to
652 | get its source.  For example, if your program is a web application, its
653 | interface could display a "Source" link that leads users to an archive
654 | of the code.  There are many ways you could offer source, and different
655 | solutions will be better for different programs; see section 13 for the
656 | specific requirements.
657 | 
658 |   You should also get your employer (if you work as a programmer) or school,
659 | if any, to sign a "copyright disclaimer" for the program, if necessary.
660 | For more information on this, and how to apply and follow the GNU AGPL, see
661 | <http://www.gnu.org/licenses/>.
662 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # PlanetEx
  2 | 
  3 | [![CircleCI](https://circleci.com/gh/sep/planet_ex.svg?style=svg)](https://circleci.com/gh/sep/planet_ex)
  4 | 
  5 | PlanetEx is an Elixir application for aggregating employee and SharePoint blogs.
  6 | 
  7 | ## Getting started
  8 | 
  9 | ### Prerequisites
 10 | 
 11 | You'll need to install the following dependencies first:
 12 | 
 13 | - [Elixir](https://elixir-lang.org/install.html) ([version](https://github.com/mhanberg/planet/blob/master/.tool-versions))
 14 | - [Erlang](https://elixir-lang.org/install.html#installing-erlang) ([version](https://github.com/mhanberg/planet/blob/master/.tool-versions))
 15 | - [PostgreSQL](https://postgresapp.com/) 10
 16 | - [Yarn](https://yarnpkg.com/en/docs/install)
 17 | - [Node](#nodejs) ([version](https://github.com/levelhq/level/blob/master/.tool-versions))
 18 | 
 19 | ### Installing
 20 | 
 21 | If you have [asdf](https://github.com/asdf-vm/asdf) installed, simply run `asdf install` in the root directory.
 22 | 
 23 | Run the bootstrap script to install the remaining dependencies and create your
 24 | development database:
 25 | 
 26 | ```bash
 27 | $ cd planet
 28 | $ bin/setup
 29 | ```
 30 | 
 31 | To run the server: `mix phx.server`.
 32 | 
 33 | ## Running the tests, formatter, and linter
 34 | 
 35 | ```bash
 36 | $ mix verify
 37 | 
 38 | ==> mix format --check-formatted
 39 | ==> mix credo
 40 | ==> mix test.all
 41 | ```
 42 | 
 43 | ## Releasing and Deployment
 44 | 
 45 | PlanetEx uses [Distillery](https://github.com/bitwalker/distillery/) and [Docker](https://www.docker.com/) to build Erlang releases targeted for Ubuntu.
 46 | 
 47 | ### Prerequisites
 48 | 
 49 | * Docker
 50 | * Server provisioned with the following
 51 |     * Postgres 10 
 52 |         * Can be hosted on the same machine as the release or seperately.
 53 |     * xvfb
 54 |     * Google Chrome
 55 |     * ChromeDriver
 56 | 
 57 | ### Release
 58 | 
 59 | * `bin/docker-build` - builds your Docker container.
 60 |     * You only need to do this once.
 61 | * `bin/release` - builds your Distillery release.
 62 |     * Build artifacts are located in `/rel/artifacts`
 63 | 
 64 | ### Deployment
 65 | 
 66 | #### Environment Variables
 67 | 
 68 | ##### Required
 69 | 
 70 | * PORT
 71 | * DOMAIN
 72 | * POOL_SIZE
 73 | * SECRET_KEY_BASE
 74 |     * Can be generated using `mix phx.gen.secret`
 75 | * DATABASE_URL
 76 | 
 77 | ##### Optional
 78 | 
 79 | * SHAREPOINT_CREDS
 80 |     * In order to aggregate blogs from protected SharePoint sites, you must supply credentials in the form of `username:password`
 81 | 
 82 | #### Deliver to remote host
 83 | * `scp rel/artifacts/<your release> user@host:/path/to/release` - Move release tar ball to the server.
 84 | * `tar -xvf /path/to/release` - unpack the release.
 85 | 
 86 | #### Start the server
 87 | 
 88 | * `/path/to/release/bin/yourapp start` - start the server in the background as a daemon
 89 |     * To stop the server - `/path/to/release/bin/yourapp stop`
 90 | or
 91 | * `/path/to/release/bin/yourapp foreground` - start the server in the foreground (analogous to `mix phx.server`)
 92 | 
 93 | ### Database migrations
 94 | 
 95 | PlanetEx comes with a migration release task.
 96 | 
 97 | On the remote server, run `/path/to/release/bin/yourapp migrate []`
 98 | 
 99 | ## Built With
100 | 
101 | - [Phoenix](http://phoenixframework.org/) - Web framework
102 | - [TailwindCSS](https://tailwindcss.com/) - CSS library
103 | 
104 | ## Contributors
105 | - Paul Steele ([ptsteele](https://github.com/ptsteele))
106 | - Mitchell Hanberg ([mhanberg](https://www.github.com/mahanberg))(alumni)
107 | 
108 | ---
109 | 
110 | [![Powered by SEP logo](https://raw.githubusercontent.com/sep/assets/master/images/powered-by-sep.svg?sanitize=true)](https://www.sep.com)
111 | 
112 | PlanetEx is supported by SEP: a Software Product Design + Development company. If you'd like to [join our team](https://www.sep.com/careers/open-positions/), don't hesitate to get in touch!
113 | 
114 | 


--------------------------------------------------------------------------------
/assets/.stylelintrc.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "stylelint-config-standard",
3 |   "rules": {
4 |     "at-rule-no-unknown": {
5 |       "ignoreAtRules": ["tailwind"]
6 |     }
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/assets/brunch-config.js:
--------------------------------------------------------------------------------
 1 | exports.config = {
 2 |   // See http://brunch.io/#documentation for docs.
 3 |   files: {
 4 |     javascripts: {
 5 |       joinTo: "js/app.js"
 6 | 
 7 |     },
 8 |     stylesheets: {
 9 |       joinTo: "css/app.css"
10 |     },
11 |     templates: {
12 |       joinTo: "js/app.js"
13 |     }
14 |   },
15 | 
16 |   conventions: {
17 |     assets: /^(static)/
18 |   },
19 | 
20 |   paths: {
21 |     watched: ["static", "css", "js", "vendor"],
22 |     public: "../priv/static"
23 |   },
24 | 
25 |   plugins: {
26 |     babel: {
27 |       ignore: [/vendor/]
28 |     },
29 |     postcss: {
30 |       processors: [
31 |         require('postcss-nested'),
32 |         require('tailwindcss')('./tailwind.js')
33 |       ]
34 |     }
35 |   },
36 | 
37 |   modules: {
38 |     autoRequire: {
39 |       "js/app.js": ["js/app"]
40 |     }
41 |   },
42 | 
43 |   npm: {
44 |     enabled: true
45 |   }
46 | };
47 | 


--------------------------------------------------------------------------------
/assets/css/app.css:
--------------------------------------------------------------------------------
 1 | @tailwind preflight;
 2 | @tailwind components;
 3 | @tailwind utilities;
 4 | 
 5 | a {
 6 |   color: #46ac4e;
 7 |   word-wrap: break-word;
 8 |   text-decoration: none;
 9 | }
10 | 
11 | a:hover {
12 |   text-decoration: underline;
13 | }
14 | 
15 | h1 {
16 |   font-size: 2rem;
17 | }
18 | 
19 | h2 {
20 |   font-size: 1.7rem;
21 | }
22 | 
23 | h3 {
24 |   font-size: 1.5rem;
25 | }
26 | 
27 | h4 {
28 |   font-size: 1.3rem;
29 | }
30 | 
31 | h5 {
32 |   font-size: 1.1rem;
33 | }
34 | 
35 | .post {
36 |   h1,
37 |   h2,
38 |   h3,
39 |   h4,
40 |   p,
41 |   ul,
42 |   ol,
43 |   div.highlight {
44 |     margin-bottom: 1rem;
45 |   }
46 | 
47 |   p,
48 |   ul,
49 |   ol {
50 |     line-height: 2;
51 |   }
52 | }
53 | 
54 | blockquote {
55 |   border-left: 3px solid #46ac4e;
56 |   font-size: 1.1em;
57 |   font-style: italic;
58 |   margin: 1.5em 0;
59 |   padding-left: 0.75em;
60 | }
61 | 
62 | @media (min-width: 320px) {
63 |   blockquote {
64 |     font-size: 0.9em;
65 |   }
66 | }
67 | 
68 | .green-focus {
69 |   outline-color: config("colors.green");
70 | }
71 | 
72 | .soft-placeholder::placeholder {
73 |   @apply text-grey;
74 | }
75 | 
76 | 


--------------------------------------------------------------------------------
/assets/css/syntax.css:
--------------------------------------------------------------------------------
 1 | .highlight {
 2 |   overflow-x: scroll;
 3 | }
 4 | .highlight table td { padding: 5px; }
 5 | .highlight table pre { margin: 0; }
 6 | .highlight, .highlight .w {
 7 |   color: #586e75;
 8 | }
 9 | .highlight .err {
10 |   color: #002b36;
11 |   background-color: #dc322f;
12 | }
13 | .highlight .c, .highlight .cd, .highlight .cm, .highlight .c1, .highlight .cs {
14 |   color: #657b83;
15 | }
16 | .highlight .cp {
17 |   color: #b58900;
18 | }
19 | .highlight .nt {
20 |   color: #b58900;
21 | }
22 | .highlight .o, .highlight .ow {
23 |   color: #93a1a1;
24 | }
25 | .highlight .p, .highlight .pi {
26 |   color: #93a1a1;
27 | }
28 | .highlight .gi {
29 |   color: #859900;
30 | }
31 | .highlight .gd {
32 |   color: #dc322f;
33 | }
34 | .highlight .gh {
35 |   color: #268bd2;
36 |   background-color: #002b36;
37 |   font-weight: bold;
38 | }
39 | .highlight .k, .highlight .kn, .highlight .kp, .highlight .kr, .highlight .kv {
40 |   color: #6c71c4;
41 | }
42 | .highlight .kc {
43 |   color: #cb4b16;
44 | }
45 | .highlight .kt {
46 |   color: #cb4b16;
47 | }
48 | .highlight .kd {
49 |   color: #cb4b16;
50 | }
51 | .highlight .s, .highlight .sb, .highlight .sc, .highlight .sd, .highlight .s2, .highlight .sh, .highlight .sx, .highlight .s1 {
52 |   color: #859900;
53 | }
54 | .highlight .sr {
55 |   color: #2aa198;
56 | }
57 | .highlight .si {
58 |   color: #d33682;
59 | }
60 | .highlight .se {
61 |   color: #d33682;
62 | }
63 | .highlight .nn {
64 |   color: #b58900;
65 | }
66 | .highlight .nc {
67 |   color: #b58900;
68 | }
69 | .highlight .no {
70 |   color: #b58900;
71 | }
72 | .highlight .na {
73 |   color: #268bd2;
74 | }
75 | .highlight .m, .highlight .mf, .highlight .mh, .highlight .mi, .highlight .il, .highlight .mo, .highlight .mb, .highlight .mx {
76 |   color: #859900;
77 | }
78 | .highlight .ss {
79 |   color: #859900;
80 | }
81 | 
82 | code.highlighter-rouge {
83 |   background-color: #f2f7f3;
84 |   border: 1px solid #edf7ed;
85 |   border-radius: 2px;
86 |   font-family: monaco, Consolas, "Lucida Console", monospace;
87 |   font-size: 0.8em;
88 |   padding: 1px 4px;
89 | }
90 | 
91 | 


--------------------------------------------------------------------------------
/assets/js/app.js:
--------------------------------------------------------------------------------
 1 | // Brunch automatically concatenates all files in your
 2 | // watched paths. Those paths can be configured at
 3 | // config.paths.watched in "brunch-config.js".
 4 | //
 5 | // However, those files will only be executed if
 6 | // explicitly imported. The only exception are files
 7 | // in vendor, which are never wrapped in imports and
 8 | // therefore are always executed.
 9 | 
10 | 
11 | import "phoenix_html";
12 | 
13 | export const PlanetEx = {
14 |   disableSubmitButton() {
15 |     const submitButton = document.getElementById("submitButton");
16 | 
17 |     submitButton.setAttribute("disabled", "");
18 |     submitButton.classList.add("opacity-50", "cursor-not-allowed");
19 |   },
20 |   openFeedMenu(e, id) {
21 |     Array.from(document.getElementsByClassName("dropdown-content"))
22 |       .forEach(dropdown => 
23 |         dropdown.id === `${id}-dropdown`
24 |         ? dropdown.classList.toggle("hidden")
25 |         : dropdown.classList.add("hidden")
26 |       );
27 | 
28 |     e.stopPropagation();
29 |   },
30 |   setupCloseFeedMenuHandler() {
31 |     window.onclick = function(event) {
32 |       if (!event.target.matches('.dropdown-button')) {
33 |         Array.from(document.getElementsByClassName("dropdown-content"))
34 |           .forEach(dropdown => dropdown.classList.add('hidden'));
35 |       }
36 |     }
37 |   }
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/assets/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "repository": {},
 3 |   "license": "MIT",
 4 |   "scripts": {
 5 |     "deploy": "brunch build --production",
 6 |     "watch": "brunch watch --stdin"
 7 |   },
 8 |   "dependencies": {
 9 |     "phoenix": "file:../deps/phoenix",
10 |     "phoenix_html": "file:../deps/phoenix_html"
11 |   },
12 |   "devDependencies": {
13 |     "babel-brunch": "7.0.1",
14 |     "brunch": "2.10.17",
15 |     "clean-css-brunch": "2.10.0",
16 |     "postcss-brunch": "^2.1.0",
17 |     "stylelint": "^9.2.1",
18 |     "stylelint-config-standard": "^18.2.0",
19 |     "tailwindcss": "^0.6.4",
20 |     "uglify-js-brunch": "2.10.0"
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/assets/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sep/planet_ex/2c24971227af9459ae15c24d7b30af3cbc014a93/assets/static/favicon.ico


--------------------------------------------------------------------------------
/assets/static/images/dots-horizontal-triple.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20"><path d="M10 12a2 2 0 1 1 0-4 2 2 0 0 1 0 4zm0-6a2 2 0 1 1 0-4 2 2 0 0 1 0 4zm0 12a2 2 0 1 1 0-4 2 2 0 0 1 0 4z"/></svg>


--------------------------------------------------------------------------------
/assets/static/images/globe.svg:
--------------------------------------------------------------------------------
1 | <svg class="fill-current text-green inline-block h-12 w-12" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20"><path d="M10 20a10 10 0 1 1 0-20 10 10 0 0 1 0 20zm2-2.25a8 8 0 0 0 4-2.46V9a2 2 0 0 1-2-2V3.07a7.95 7.95 0 0 0-3-1V3a2 2 0 0 1-2 2v1a2 2 0 0 1-2 2v2h3a2 2 0 0 1 2 2v5.75zm-4 0V15a2 2 0 0 1-2-2v-1h-.5A1.5 1.5 0 0 1 4 10.5V8H2.25A8.01 8.01 0 0 0 8 17.75z"/></svg>
2 | 


--------------------------------------------------------------------------------
/assets/static/images/phoenix.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sep/planet_ex/2c24971227af9459ae15c24d7b30af3cbc014a93/assets/static/images/phoenix.png


--------------------------------------------------------------------------------
/assets/static/robots.txt:
--------------------------------------------------------------------------------
1 | # See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
2 | #
3 | # To ban all spiders from the entire site uncomment the next two lines:
4 | # User-agent: *
5 | # Disallow: /
6 | 


--------------------------------------------------------------------------------
/assets/tailwind.js:
--------------------------------------------------------------------------------
  1 | let colors = {
  2 |   'transparent': 'transparent',
  3 | 
  4 |   'charcoal': '#4A4A4A',
  5 |   'label-grey': '#333333',
  6 |   'black': '#22292f',
  7 |   'grey-darkest': '#3d4852',
  8 |   'grey-darker': '#606f7b',
  9 |   'grey-dark': '#8795a1',
 10 |   'grey': '#b8c2cc',
 11 |   'grey-light': '#dae1e7',
 12 |   'grey-lighter': '#f1f5f8',
 13 |   'grey-lightest': '#f8fafc',
 14 |   'white': '#ffffff',
 15 | 
 16 |   'red-darkest': '#3b0d0c',
 17 |   'red-darker': '#621b18',
 18 |   'red-dark': '#cc1f1a',
 19 |   'red': '#e3342f',
 20 |   'red-light': '#ef5753',
 21 |   'red-lighter': '#f9acaa',
 22 |   'red-lightest': '#fcebea',
 23 | 
 24 |   'orange-darkest': '#462a16',
 25 |   'orange-darker': '#613b1f',
 26 |   'orange-dark': '#de751f',
 27 |   'orange': '#f6993f',
 28 |   'orange-light': '#faad63',
 29 |   'orange-lighter': '#fcd9b6',
 30 |   'orange-lightest': '#fff5eb',
 31 | 
 32 |   'yellow-darkest': '#453411',
 33 |   'yellow-darker': '#684f1d',
 34 |   'yellow-dark': '#f2d024',
 35 |   'yellow': '#ffed4a',
 36 |   'yellow-light': '#fff382',
 37 |   'yellow-lighter': '#fff9c2',
 38 |   'yellow-lightest': '#fcfbeb',
 39 | 
 40 |   'green-ultimate-light': '#F2F7F3',
 41 |   'green-lightest': '#EDF7ED',
 42 |   'green-lighter': '#B5DEB8',
 43 |   'green-light': '#7EC583',
 44 |   'green': '#46AC4E',
 45 |   'green-dark': '#3F9B46',
 46 |   'green-darker': '#2A672F',
 47 |   'green-darkest': '#153417',
 48 | 
 49 |   'teal-darkest': '#0d3331',
 50 |   'teal-darker': '#20504f',
 51 |   'teal-dark': '#38a89d',
 52 |   'teal': '#4dc0b5',
 53 |   'teal-light': '#64d5ca',
 54 |   'teal-lighter': '#a0f0ed',
 55 |   'teal-lightest': '#e8fffe',
 56 | 
 57 |   'blue-darkest': '#12283a',
 58 |   'blue-darker': '#1c3d5a',
 59 |   'blue-dark': '#2779bd',
 60 |   'blue': '#3490dc',
 61 |   'blue-light': '#6cb2eb',
 62 |   'blue-lighter': '#bcdefa',
 63 |   'blue-lightest': '#eff8ff',
 64 | 
 65 |   'indigo-darkest': '#191e38',
 66 |   'indigo-darker': '#2f365f',
 67 |   'indigo-dark': '#5661b3',
 68 |   'indigo': '#6574cd',
 69 |   'indigo-light': '#7886d7',
 70 |   'indigo-lighter': '#b2b7ff',
 71 |   'indigo-lightest': '#e6e8ff',
 72 | 
 73 |   'purple-darkest': '#21183c',
 74 |   'purple-darker': '#382b5f',
 75 |   'purple-dark': '#794acf',
 76 |   'purple': '#9561e2',
 77 |   'purple-light': '#a779e9',
 78 |   'purple-lighter': '#d6bbfc',
 79 |   'purple-lightest': '#f3ebff',
 80 | 
 81 |   'pink-darkest': '#451225',
 82 |   'pink-darker': '#6f213f',
 83 |   'pink-dark': '#eb5286',
 84 |   'pink': '#f66d9b',
 85 |   'pink-light': '#fa7ea8',
 86 |   'pink-lighter': '#ffbbca',
 87 |   'pink-lightest': '#ffebef',
 88 | }
 89 | 
 90 | module.exports = {
 91 |   colors: colors,
 92 |   screens: {
 93 |     'xs': '320px',
 94 |     'sm': '576px',
 95 |     'md': '768px',
 96 |     'lg': '992px',
 97 |   },
 98 |   fonts: {
 99 |     'sans': [
100 |       'system-ui',
101 |       'BlinkMacSystemFont',
102 |       '-apple-system',
103 |       'Segoe UI',
104 |       'Roboto',
105 |       'Oxygen',
106 |       'Ubuntu',
107 |       'Cantarell',
108 |       'Fira Sans',
109 |       'Droid Sans',
110 |       'Helvetica Neue',
111 |       'sans-serif',
112 |     ],
113 |     'serif': [
114 |       'Constantia',
115 |       'Lucida Bright',
116 |       'Lucidabright',
117 |       'Lucida Serif',
118 |       'Lucida',
119 |       'DejaVu Serif',
120 |       'Bitstream Vera Serif',
121 |       'Liberation Serif',
122 |       'Georgia',
123 |       'serif',
124 |     ],
125 |     'mono': [
126 |       'Menlo',
127 |       'Monaco',
128 |       'Consolas',
129 |       'Liberation Mono',
130 |       'Courier New',
131 |       'monospace',
132 |     ]
133 |   },
134 |   textSizes: {
135 |     'xs': '.75rem',     // 12px
136 |     'sm': '.875rem',    // 14px
137 |     'base': '1rem',     // 16px
138 |     'lg': '1.125rem',   // 18px
139 |     'xl': '1.25rem',    // 20px
140 |     '2xl': '1.5rem',    // 24px
141 |     '3xl': '1.875rem',  // 30px
142 |     '4xl': '2.25rem',   // 36px
143 |     '5xl': '3rem',      // 48px
144 |   },
145 |   fontWeights: {
146 |     'hairline': 100,
147 |     'thin': 200,
148 |     'light': 300,
149 |     'normal': 400,
150 |     'medium': 500,
151 |     'semibold': 600,
152 |     'bold': 700,
153 |     'extrabold': 800,
154 |     'black': 900,
155 |   },
156 |   leading: {
157 |     'none': 1,
158 |     'tight': 1.25,
159 |     'normal': 1.5,
160 |     'loose': 2,
161 |   },
162 |   tracking: {
163 |     'tight': '-0.05em',
164 |     'normal': '0',
165 |     'wide': '0.05em',
166 |   },
167 |   textColors: colors,
168 |   backgroundColors: colors,
169 |   backgroundSize: {
170 |     'auto': 'auto',
171 |     'cover': 'cover',
172 |     'contain': 'contain',
173 |   },
174 |   borderWidths: {
175 |     default: '1px',
176 |     '0': '0',
177 |     '2': '2px',
178 |     '4': '4px',
179 |     '7': '7px',
180 |     '8': '8px',
181 |   },
182 |   borderColors: global.Object.assign({ default: colors['grey-light'] }, colors),
183 |   borderRadius: {
184 |     'none': '0',
185 |     'sm': '.125rem',
186 |     default: '.25rem',
187 |     'lg': '.5rem',
188 |     'full': '9999px',
189 |   },
190 |   width: {
191 |     'auto': 'auto',
192 |     'px': '1px',
193 |     '1': '0.25rem',
194 |     '2': '0.5rem',
195 |     '3': '0.75rem',
196 |     '4': '1rem',
197 |     '6': '1.5rem',
198 |     '8': '2rem',
199 |     '10': '2.5rem',
200 |     '12': '3rem',
201 |     '16': '4rem',
202 |     '24': '6rem',
203 |     '32': '8rem',
204 |     '48': '12rem',
205 |     '64': '16rem',
206 |     '1/2': '50%',
207 |     '1/3': '33.33333%',
208 |     '2/3': '66.66667%',
209 |     '1/4': '25%',
210 |     '3/4': '75%',
211 |     '1/5': '20%',
212 |     '2/5': '40%',
213 |     '3/5': '60%',
214 |     '4/5': '80%',
215 |     '1/6': '16.66667%',
216 |     '5/6': '83.33333%',
217 |     'full': '100%',
218 |     'screen': '100vw'
219 |   },
220 |   height: {
221 |     'auto': 'auto',
222 |     'px': '1px',
223 |     '1': '0.25rem',
224 |     '2': '0.5rem',
225 |     '3': '0.75rem',
226 |     '4': '1rem',
227 |     '6': '1.5rem',
228 |     '8': '2rem',
229 |     '10': '2.5rem',
230 |     '12': '3rem',
231 |     '16': '4rem',
232 |     '24': '6rem',
233 |     '32': '8rem',
234 |     '48': '12rem',
235 |     '64': '16rem',
236 |     'full': '100%',
237 |     'screen': '100vh'
238 |   },
239 |   minWidth: {
240 |     '0': '0',
241 |     'full': '100%',
242 |   },
243 |   minHeight: {
244 |     '0': '0',
245 |     'full': '100%',
246 |     'screen': '100vh'
247 |   },
248 |   maxWidth: {
249 |     'xs': '20rem',
250 |     'xs-sm': '25rem',
251 |     'sm': '30rem',
252 |     'md': '40rem',
253 |     'lg': '50rem',
254 |     'xl': '60rem',
255 |     '2xl': '70rem',
256 |     '3xl': '80rem',
257 |     '4xl': '90rem',
258 |     '5xl': '100rem',
259 |     'full': '100%',
260 |   },
261 |   maxHeight: {
262 |     'full': '100%',
263 |     'screen': '100vh',
264 |   },
265 |   padding: {
266 |     'px': '1px',
267 |     '0': '0',
268 |     '1': '0.25rem',
269 |     '2': '0.5rem',
270 |     '3': '0.75rem',
271 |     '4': '1rem',
272 |     '6': '1.5rem',
273 |     '8': '2rem',
274 |     '12': '3rem'
275 |   },
276 |   margin: {
277 |     'auto': 'auto',
278 |     'px': '1px',
279 |     '0': '0',
280 |     '1': '0.25rem',
281 |     '2': '0.5rem',
282 |     '3': '0.75rem',
283 |     '4': '1rem',
284 |     '6': '1.5rem',
285 |     '8': '2rem',
286 |     '12': '3rem'
287 |   },
288 |   negativeMargin: {
289 |     'px': '1px',
290 |     '0': '0',
291 |     '1': '0.25rem',
292 |     '2': '0.5rem',
293 |     '3': '0.75rem',
294 |     '4': '1rem',
295 |     '6': '1.5rem',
296 |     '8': '2rem',
297 |   },
298 |   shadows: {
299 |     default: '0 2px 4px 0 rgba(0,0,0,0.10)',
300 |     'md': '0 4px 8px 0 rgba(0,0,0,0.12), 0 2px 4px 0 rgba(0,0,0,0.08)',
301 |     'lg': '0 15px 30px 0 rgba(0,0,0,0.11), 0 5px 15px 0 rgba(0,0,0,0.08)',
302 |     'inner': 'inset 0 2px 4px 0 rgba(0,0,0,0.06)',
303 |     'none': 'none',
304 |   },
305 |   zIndex: {
306 |     'auto': 'auto',
307 |     '0': 0,
308 |     '10': 10,
309 |     '20': 20,
310 |     '30': 30,
311 |     '40': 40,
312 |     '50': 50,
313 |   },
314 |   opacity: {
315 |     '0': '0',
316 |     '25': '.25',
317 |     '50': '.5',
318 |     '75': '.75',
319 |     '100': '1',
320 |   },
321 |   svgFill: {
322 |     'current': 'currentColor',
323 |   },
324 |   svgStroke: {
325 |     'current': 'currentColor',
326 |   },
327 |   modules: {
328 |     appearance: ['responsive'],
329 |     backgroundAttachment: ['responsive'],
330 |     backgroundColors: ['responsive', 'hover'],
331 |     backgroundPosition: ['responsive'],
332 |     backgroundRepeat: ['responsive'],
333 |     backgroundSize: ['responsive'],
334 |     borderColors: ['responsive', 'hover'],
335 |     borderRadius: ['responsive'],
336 |     borderStyle: ['responsive'],
337 |     borderWidths: ['responsive'],
338 |     cursor: ['responsive'],
339 |     display: ['responsive'],
340 |     flexbox: ['responsive'],
341 |     float: ['responsive'],
342 |     fonts: ['responsive'],
343 |     fontWeights: ['responsive', 'hover'],
344 |     height: ['responsive'],
345 |     leading: ['responsive'],
346 |     lists: ['responsive'],
347 |     margin: ['responsive'],
348 |     maxHeight: ['responsive'],
349 |     maxWidth: ['responsive'],
350 |     minHeight: ['responsive'],
351 |     minWidth: ['responsive'],
352 |     negativeMargin: ['responsive'],
353 |     opacity: ['responsive'],
354 |     overflow: ['responsive'],
355 |     padding: ['responsive'],
356 |     pointerEvents: ['responsive'],
357 |     position: ['responsive'],
358 |     resize: ['responsive'],
359 |     shadows: ['responsive'],
360 |     svgFill: [],
361 |     svgStroke: [],
362 |     textAlign: ['responsive'],
363 |     textColors: ['responsive', 'hover'],
364 |     textSizes: ['responsive'],
365 |     textStyle: ['responsive', 'hover'],
366 |     tracking: ['responsive'],
367 |     userSelect: ['responsive'],
368 |     verticalAlign: ['responsive'],
369 |     visibility: ['responsive'],
370 |     whitespace: ['responsive'],
371 |     width: ['responsive'],
372 |     zIndex: ['responsive'],
373 |   },
374 |   plugins: [
375 |     require('tailwindcss/plugins/container')({
376 |       center: true,
377 |       // padding: '1rem',
378 |     }),
379 |   ],
380 |   options: {
381 |     prefix: '',
382 |     important: false,
383 |     separator: ':',
384 |   },
385 | }
386 | 


--------------------------------------------------------------------------------
/bin/build:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -ev
 4 | 
 5 | APP_NAME="$(grep 'app:' mix.exs | sed -e 's/\[//g' -e 's/ //g' -e 's/app://' -e 's/[:,]//g')"
 6 | APP_VSN="$(grep 'version:' mix.exs | cut -d '"' -f2)"
 7 | 
 8 | cd /opt/build
 9 | 
10 | mkdir -p /opt/build/rel/artifacts
11 | 
12 | rm -rf _build/prod
13 | 
14 | # Install updated versions of hex/rebar
15 | mix local.rebar --force
16 | mix local.hex --if-missing --force
17 | 
18 | export MIX_ENV=prod
19 | 
20 | # Fetch deps and compile
21 | mix deps.get --only prod
22 | # Run an explicit clean to remove any build artifacts from the host
23 | mix clean
24 | mix compile --force
25 | 
26 | (cd assets; yarn install; node_modules/brunch/bin/brunch build --production)
27 | mix phx.digest
28 | # Build the release
29 | mix release --verbose
30 | # Copy tarball to output
31 | cp "_build/prod/rel/$APP_NAME/releases/$APP_VSN/$APP_NAME.tar.gz" rel/artifacts/"$APP_NAME-$APP_VSN.tar.gz"
32 | 
33 | exit 0
34 | 


--------------------------------------------------------------------------------
/bin/docker-build:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | 
3 | set -ev
4 | 
5 | docker build -t planet-image .
6 | 
7 | exit 0
8 | 


--------------------------------------------------------------------------------
/bin/release:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | 
3 | set -ev
4 | 
5 | docker run -v "$(pwd)":/opt/build --rm -it planet-image:latest /opt/build/bin/build
6 | 
7 | exit 0
8 | 


--------------------------------------------------------------------------------
/bin/setup:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # script/setup: Install project dependencies and setup the local environment.
 4 | 
 5 | set -e
 6 | 
 7 | cat <<"EOF"
 8 | * * * * * * * * * * * * * * * * * * * * * *
 9 | *         PlanetEx Bootstrap Script         *
10 | * * * * * * * * * * * * * * * * * * * * * *
11 | EOF
12 | 
13 | # Verify that elixir is installed
14 | command -v mix >/dev/null 2>&1 || {
15 |   echo >&2 "Whoops! You need to install Elixir first.";
16 |   echo >&2 "Follow the instructions here, then try again:";
17 |   echo >&2 "https://elixir-lang.org/install.html";
18 |   exit 1;
19 | }
20 | 
21 | # Verify that yarn is installed
22 | command -v yarn >/dev/null 2>&1 || {
23 |   echo >&2 "Whoops! You need to install Yarn first.";
24 |   echo >&2 "Follow the instructions here, then try again:";
25 |   echo >&2 "https://yarnpkg.com/en/docs/install";
26 |   exit 1;
27 | }
28 | 
29 | # Verify that Postgres is installed
30 | command -v psql >/dev/null 2>&1 || {
31 |   echo >&2 "Whoops! You need to install Postgres first.";
32 |   echo >&2 "We recommend Postgres.app for Mac:";
33 |   echo >&2 "https://postgresapp.com";
34 |   exit 1;
35 | }
36 | 
37 | # Verify that Chromedriver is installed
38 | command -v chromedriver >/dev/null 2>&1 || {
39 |   echo >&2 "Whoops! You need to install chromedriver first.";
40 |   echo >&2 "Follow the instructions here, then try again:";
41 |   echo >&2 "http://chromedriver.chromium.org/downloads";
42 |   exit 1;
43 | }
44 | 
45 | # Install dependencies
46 | echo "==> Installing Elixir dependencies"
47 | mix deps.get
48 | 
49 | # Install node dependencies
50 | echo "==> Installing node.js dependencies"
51 | cd assets && yarn
52 | 
53 | # Setup the local database
54 | echo "==> Creating the development database"
55 | cd ../ && mix ecto.setup
56 | 


--------------------------------------------------------------------------------
/config/config.exs:
--------------------------------------------------------------------------------
 1 | # This file is responsible for configuring your application
 2 | # and its dependencies with the aid of the Mix.Config module.
 3 | #
 4 | # This configuration file is loaded before any dependency and
 5 | # is restricted to this project.
 6 | use Mix.Config
 7 | 
 8 | # General application configuration
 9 | config :planetex, ecto_repos: [PlanetEx.Repo]
10 | 
11 | # Configures the endpoint
12 | config :planetex, PlanetExWeb.Endpoint,
13 |   url: [host: "localhost"],
14 |   secret_key_base: "TYlZ+tfWNCIki6f8W7avWBhwzG0t6Yio8z21KcV0JcnGy0T9fP1i0qyG8TR16I3/",
15 |   render_errors: [view: PlanetExWeb.ErrorView, accepts: ~w(html json)],
16 |   pubsub: [name: PlanetEx.PubSub, adapter: Phoenix.PubSub.PG2]
17 | 
18 | # Configures Elixir's Logger
19 | config :logger, :console,
20 |   format: "$time $metadata[$level] $message\n",
21 |   metadata: [:user_id]
22 | 
23 | config :planetex, :server_farm_supervisor, PlanetEx.Core.ServerFarmSupervisor
24 | config :planetex, :server_timeout, 60000
25 | 
26 | config :wallaby,
27 |   screenshot_on_failure: true,
28 |   chrome: [headless: true],
29 |   driver: Wallaby.Experimental.Chrome
30 | 
31 | # Import environment specific config. This must remain at the bottom
32 | # of this file so it overrides the configuration defined above.
33 | import_config "#{Mix.env()}.exs"
34 | 


--------------------------------------------------------------------------------
/config/dev.exs:
--------------------------------------------------------------------------------
 1 | use Mix.Config
 2 | 
 3 | # For development, we disable any cache and enable
 4 | # debugging and code reloading.
 5 | #
 6 | # The watchers configuration can be used to run external
 7 | # watchers to your application. For example, we use it
 8 | # with brunch.io to recompile .js and .css sources.
 9 | config :planetex, PlanetExWeb.Endpoint,
10 |   http: [port: 4000],
11 |   debug_errors: true,
12 |   code_reloader: true,
13 |   check_origin: false,
14 |   watchers: [
15 |     node: [
16 |       "node_modules/brunch/bin/brunch",
17 |       "watch",
18 |       "--stdin",
19 |       cd: Path.expand("../assets", __DIR__)
20 |     ]
21 |   ]
22 | 
23 | # ## SSL Support
24 | #
25 | # In order to use HTTPS in development, a self-signed
26 | # certificate can be generated by running the following
27 | # command from your terminal:
28 | #
29 | #     openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 -subj "/C=US/ST=Denial/L=Springfield/O=Dis/CN=www.example.com" -keyout priv/server.key -out priv/server.pem
30 | #
31 | # The `http:` config above can be replaced with:
32 | #
33 | #     https: [port: 4000, keyfile: "priv/server.key", certfile: "priv/server.pem"],
34 | #
35 | # If desired, both `http:` and `https:` keys can be
36 | # configured to run both http and https servers on
37 | # different ports.
38 | 
39 | # Watch static and templates for browser reloading.
40 | config :planetex, PlanetExWeb.Endpoint,
41 |   live_reload: [
42 |     patterns: [
43 |       ~r{priv/static/.*(js|css|png|jpeg|jpg|gif|svg)$},
44 |       ~r{priv/gettext/.*(po)$},
45 |       ~r{lib/planet_web/views/.*(ex)$},
46 |       ~r{lib/planet_web/templates/.*(eex)$}
47 |     ]
48 |   ]
49 | 
50 | # Do not include metadata nor timestamps in development logs
51 | config :logger, :console, format: "[$level] $message\n"
52 | 
53 | # Set a higher stacktrace during development. Avoid configuring such
54 | # in production as building large stacktraces may be expensive.
55 | config :phoenix, :stacktrace_depth, 20
56 | 
57 | # Configure your database
58 | config :planetex, PlanetEx.Repo,
59 |   adapter: Ecto.Adapters.Postgres,
60 |   username: "postgres",
61 |   password: "postgres",
62 |   database: "planet_dev",
63 |   hostname: "localhost",
64 |   pool_size: 10
65 | 


--------------------------------------------------------------------------------
/config/prod.exs:
--------------------------------------------------------------------------------
 1 | use Mix.Config
 2 | 
 3 | # For production, we often load configuration from external
 4 | # sources, such as your system environment. For this reason,
 5 | # you won't find the :http configuration below, but set inside
 6 | # PlanetExWeb.Endpoint.init/2 when load_from_system_env is
 7 | # true. Any dynamic configuration should be done there.
 8 | #
 9 | # Don't forget to configure the url host to something meaningful,
10 | # Phoenix uses this information when generating URLs.
11 | #
12 | # Finally, we also include the path to a cache manifest
13 | # containing the digested version of static files. This
14 | # manifest is generated by the mix phx.digest task
15 | # which you typically run after static files are built.
16 | config :planetex, PlanetExWeb.Endpoint,
17 |   load_from_system_env: true,
18 |   cache_static_manifest: "priv/static/cache_manifest.json",
19 |   server: true,
20 |   root: ".",
21 |   version: Application.spec(:phoenix_distillery, :vsn)
22 | 
23 | # Do not print debug messages in production
24 | config :logger, level: :info
25 | 
26 | # Configure your database
27 | config :planetex, PlanetEx.Repo,
28 |   adapter: Ecto.Adapters.Postgres,
29 |   load_from_system_env: true
30 | 


--------------------------------------------------------------------------------
/config/test.exs:
--------------------------------------------------------------------------------
 1 | use Mix.Config
 2 | 
 3 | config :planetex, PlanetExWeb.Endpoint,
 4 |   http: [port: 4001],
 5 |   server: true
 6 | 
 7 | config :planetex, :sql_sandbox, true
 8 | 
 9 | config :wallaby, chrome: [headless: true]
10 | 
11 | # Print only warnings and errors during test
12 | config :logger, level: :warn
13 | 
14 | # Configure your database
15 | config :planetex, PlanetEx.Repo,
16 |   adapter: Ecto.Adapters.Postgres,
17 |   username: "postgres",
18 |   password: "postgres",
19 |   database: "planet_test",
20 |   hostname: "localhost",
21 |   pool: Ecto.Adapters.SQL.Sandbox,
22 |   ownership_timeout: 999_999
23 | 
24 | config :planetex, :fetcher, FetchMock
25 | config :planetex, :server_farm_supervisor, nil
26 | 


--------------------------------------------------------------------------------
/hooks/pre-commit:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | #
 3 | # An example hook script to verify what is about to be committed.
 4 | # Called by "git commit" with no arguments.  The hook should
 5 | # exit with non-zero status after issuing an appropriate message if
 6 | # it wants to stop the commit.
 7 | #
 8 | # To enable this hook, rename this file to "pre-commit".
 9 | 
10 | git --no-pager diff --name-only --cached | grep -E "\\.(ex|exs)$" | xargs mix format --check-formatted
11 | git --no-pager diff --name-only --cached | grep -E "\\.(ex|exs)$" | xargs -n 1 mix credo --strict
12 | 
13 | 


--------------------------------------------------------------------------------
/lib/planet.ex:
--------------------------------------------------------------------------------
 1 | defmodule Planet do
 2 |   @moduledoc """
 3 |   Planet keeps the contexts that define your domain
 4 |   and business logic.
 5 | 
 6 |   Contexts are also responsible for managing your data, regardless
 7 |   if it comes from the database, an external API or others.
 8 |   """
 9 | end
10 | 


--------------------------------------------------------------------------------
/lib/planet/application.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Application do
 2 |   @moduledoc false
 3 |   @server_farm_supervisor Application.get_env(:planetex, :server_farm_supervisor)
 4 | 
 5 |   use Application
 6 | 
 7 |   def start(_type, _args) do
 8 |     children =
 9 |       Enum.filter(
10 |         [
11 |           PlanetEx.Repo,
12 |           PlanetExWeb.Endpoint,
13 |           @server_farm_supervisor
14 |         ],
15 |         & &1
16 |       )
17 | 
18 |     opts = [strategy: :one_for_one, name: PlanetEx.Supervisor]
19 |     Supervisor.start_link(children, opts)
20 |   end
21 | 
22 |   def config_change(changed, _new, removed) do
23 |     PlanetExWeb.Endpoint.config_change(changed, removed)
24 |     :ok
25 |   end
26 | end
27 | 


--------------------------------------------------------------------------------
/lib/planet/core/cron.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.Cron do
 2 |   @moduledoc """
 3 |   This module will call the passed in function on a recurring basis.
 4 |   """
 5 |   use GenServer
 6 | 
 7 |   @timeout Application.get_env(:planetex, :server_timeout)
 8 | 
 9 |   def start_link(job) do
10 |     GenServer.start_link(__MODULE__, job)
11 |   end
12 | 
13 |   def init(job) do
14 |     job.()
15 | 
16 |     schedule_refresh()
17 | 
18 |     {:ok, job}
19 |   end
20 | 
21 |   def handle_info(:run, job) do
22 |     job.()
23 | 
24 |     schedule_refresh()
25 | 
26 |     {:noreply, job}
27 |   end
28 | 
29 |   defp schedule_refresh do
30 |     Process.send_after(self(), :run, @timeout)
31 |   end
32 | end
33 | 


--------------------------------------------------------------------------------
/lib/planet/core/feed_fetcher.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.FeedFetcher do
 2 |   @moduledoc """
 3 |   This module is responsible for for fetching Feed data.
 4 |   """
 5 |   require Logger
 6 |   alias PlanetEx.Feeds.Rss
 7 |   use Wallaby.DSL
 8 | 
 9 |   @callback get(rss :: %Rss{}) :: String.t()
10 |   def get(%Rss{is_sharepoint: false, url: url}) do
11 |     case HTTPoison.get(url, [], follow_redirect: true) do
12 |       {:ok, response} ->
13 |         response.body
14 | 
15 |       {:error, _r} ->
16 |         ""
17 |     end
18 |   end
19 | 
20 |   def get(%Rss{is_sharepoint: true, url: url}) do
21 |     match = Regex.named_captures(~r{(?<protocol>http://|https://)(?<sharepoint_url>.*)}, url)
22 | 
23 |     url_with_creds =
24 |       match["protocol"] <> System.get_env("SHAREPOINT_CREDS") <> "@" <> match["sharepoint_url"]
25 | 
26 |     try do
27 |       {:ok, session} = Wallaby.start_session()
28 | 
29 |       feed =
30 |         session
31 |         |> visit(url_with_creds)
32 |         |> execute_script("""
33 |         fetch("#{url}")
34 |           .then(r => r.text())
35 |           .then(t => document.querySelector("html").innerHTML = t);
36 |         """)
37 |         |> page_source
38 | 
39 |       session
40 |       |> Wallaby.end_session()
41 | 
42 |       feed
43 |     rescue
44 |       e ->
45 |         Logger.error("Error fetching sharepoint feed: #{inspect e}")
46 | 
47 |         ""
48 |     end
49 |   end
50 | end
51 | 


--------------------------------------------------------------------------------
/lib/planet/core/feed_parser/atom.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.FeedParser.Atom do
 2 |   @moduledoc """
 3 |   This module understands how to parse an Atom feed.
 4 |   """
 5 |   alias PlanetEx.Core.FeedParser.{Entry, Feed}
 6 |   import SweetXml
 7 | 
 8 |   def parse(xml) do
 9 |     %Feed{}
10 |     |> put_title(xml)
11 |     |> put_url(xml)
12 |     |> put_author(xml)
13 |     |> put_entries(xml)
14 |   end
15 | 
16 |   defp put_entries(%Feed{} = feed, xml) do
17 |     entries =
18 |       xml
19 |       |> xpath(~x"./entry"l)
20 |       |> Enum.map(fn entry -> to_entry(entry, feed) end)
21 | 
22 |     struct(feed, entries: entries)
23 |   end
24 | 
25 |   defp to_entry(entry_xml, feed) do
26 |     %Entry{}
27 |     |> put_title(entry_xml)
28 |     |> put_url(entry_xml)
29 |     |> put_author(entry_xml, feed)
30 |     |> put_content(entry_xml, feed)
31 |     |> put_published(entry_xml)
32 |   end
33 | 
34 |   defp put_content(%Entry{} = entry, xml, feed) do
35 |     content =
36 |       xml
37 |       |> xpath(~x"./content/text()"s)
38 |       |> Entry.convert_relative_urls(feed.url)
39 | 
40 |     struct(entry, content: content)
41 |   end
42 | 
43 |   defp put_published(%Entry{} = entry, xml) do
44 |     published =
45 |       xml
46 |       |> xpath(~x"./updated/text()"s)
47 |       |> parse_date
48 | 
49 |     struct(entry, published: published)
50 |   end
51 | 
52 |   defp parse_date(date) do
53 |     Timex.parse!(date, "{ISO:Extended}")
54 |   end
55 | 
56 |   defp put_title(struct, xml) do
57 |     struct(struct, title: xpath(xml, ~x"./title/text()"s))
58 |   end
59 | 
60 |   defp put_url(struct, xml) do
61 |     struct(struct, url: xpath(xml, ~x"./link[@rel='alternate']/@href"s))
62 |   end
63 | 
64 |   defp put_author(struct, xml) do
65 |     struct(struct, author: xpath(xml, ~x"./author/name/text()"s))
66 |   end
67 | 
68 |   defp put_author(struct, xml, feed) do
69 |     author =
70 |       case xpath(xml, ~x"./author/name/text()"s) do
71 |         "" ->
72 |           feed.author
73 | 
74 |         entry_author ->
75 |           entry_author
76 |       end
77 | 
78 |     struct(struct, author: author)
79 |   end
80 | end
81 | 


--------------------------------------------------------------------------------
/lib/planet/core/feed_parser/entry.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.FeedParser.Entry do
 2 |   @moduledoc """
 3 |   This module represents an Entry, an item in a Feed.
 4 |   """
 5 |   defstruct [:title, :url, :author, :content, :published]
 6 | 
 7 |   def convert_relative_urls(content, url) do
 8 |     content
 9 |     |> String.replace(~r{(href|src)=(?:"|')/(.*?)(?:"|')}, "\\1=\"#{url}\\2\"")
10 |   end
11 | end
12 | 


--------------------------------------------------------------------------------
/lib/planet/core/feed_parser/feed.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.FeedParser.Feed do
 2 |   @moduledoc """
 3 |   This module represents a feed and certain operations that can be done on a feed.
 4 |   """
 5 |   defstruct [:title, :url, :author, entries: []]
 6 | 
 7 |   def with_entries(feed, page, per_page) do
 8 |     selected_entries =
 9 |       feed.entries
10 |       |> Enum.chunk_every(per_page)
11 |       |> Enum.at(page - 1)
12 | 
13 |     struct(feed, entries: selected_entries)
14 |   end
15 | 
16 |   def merge(feeds, feed) when is_list(feeds) do
17 |     struct(feed, entries: combine_and_sort_entries(feeds))
18 |   end
19 | 
20 |   defp combine_and_sort_entries(feeds) do
21 |     feeds
22 |     |> Enum.flat_map(& &1.entries)
23 |     |> Enum.sort_by(& &1.published, &Timex.after?/2)
24 |   end
25 | end
26 | 


--------------------------------------------------------------------------------
/lib/planet/core/feed_parser/feed_parser.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.FeedParser do
 2 |   @moduledoc """
 3 |   This module coordinates parsing feeds, delegating to the appropriate parser.
 4 |   """
 5 |   require Logger
 6 |   alias PlanetEx.Core.FeedParser.{Atom, Feed, Rss, Sharepoint}
 7 | 
 8 |   def parse(""), do: %Feed{}
 9 | 
10 |   def parse(raw_feed) do
11 |     raw_feed
12 |     |> SweetXml.parse()
13 |     |> case do
14 |       {_, :feed, _, _, _, _, _, _, _, _, _, _} = feed ->
15 |         Atom.parse(feed)
16 | 
17 |       {_, :rss, _, _, _, _, _, _, _, _, _, _} = feed ->
18 |         Rss.parse(feed)
19 | 
20 |       {_, :html, _, _, _, _, _, _, _, _, _, _} = feed ->
21 |         Sharepoint.parse(feed)
22 | 
23 |       unknown ->
24 |         Logger.error("Error parsing a feed, this is what I got: #{inspect raw_feed}")
25 |         Logger.error("This is what was parsed #{inspect unknown}")
26 |         nil
27 |     end
28 |   end
29 | end
30 | 


--------------------------------------------------------------------------------
/lib/planet/core/feed_parser/rss.ex:
--------------------------------------------------------------------------------
  1 | defmodule PlanetEx.Core.FeedParser.Rss do
  2 |   @moduledoc """
  3 |   This module understands how to parse an RSS feed.
  4 |   """
  5 |   require Logger
  6 |   alias PlanetEx.Core.FeedParser.{Entry, Feed}
  7 |   import SweetXml
  8 | 
  9 |   def parse(xml) do
 10 |     xml = xpath(xml, ~x"./channel"e)
 11 | 
 12 |     %Feed{}
 13 |     |> put_title(xml)
 14 |     |> put_url(xml)
 15 |     |> put_entries(xml)
 16 |   end
 17 | 
 18 |   defp put_entries(%Feed{} = feed, xml) do
 19 |     entries =
 20 |       xml
 21 |       |> xpath(~x"./item"le)
 22 |       |> Enum.map(fn entry -> to_entry(entry, feed) end)
 23 | 
 24 |     struct(feed, entries: entries)
 25 |   end
 26 | 
 27 |   defp to_entry(entry_xml, feed) do
 28 |     %Entry{}
 29 |     |> put_title(entry_xml)
 30 |     |> put_url(entry_xml)
 31 |     |> put_author(entry_xml)
 32 |     |> put_content(entry_xml, feed)
 33 |     |> put_published(entry_xml)
 34 |   end
 35 | 
 36 |   defp put_content(%Entry{} = entry, xml, feed) do
 37 |     content =
 38 |       xml
 39 |       |> get_content()
 40 |       |> Entry.convert_relative_urls(feed.url)
 41 | 
 42 |     struct(entry, content: content)
 43 |   end
 44 | 
 45 |   defp get_content(xml) do
 46 |     content_encoded(xml) || description(xml) || ""
 47 |   end
 48 | 
 49 |   defp content_encoded(xml) do
 50 |     xpath(xml, ~x"./content:encoded/text()"so)
 51 |   end
 52 | 
 53 |   defp description(xml) do
 54 |     xml
 55 |     |> xpath(~x"./description/text()"so)
 56 |     |> String.trim()
 57 |     |> case do
 58 |       "" ->
 59 |         xml
 60 |         |> xpath(~x"./description")
 61 |         |> elem(8)
 62 |         |> :xmerl.export_simple_content(:xmerl_html)
 63 |         |> List.to_string()
 64 | 
 65 |       desc ->
 66 |         desc
 67 |     end
 68 |   end
 69 | 
 70 |   defp put_published(%Entry{} = entry, xml) do
 71 |     published =
 72 |       (xpath(xml, ~x"./pubDate/text()"so) || xpath(xml, ~x"./pubdate/text()"so))
 73 |       |> parse_date
 74 | 
 75 |     struct(entry, published: published)
 76 |   end
 77 | 
 78 |   defp parse_date(date) do
 79 |     parse_rfc_822(date) || parse_rfc_1123(date) || parse_rfc_1123_published_on(date) ||
 80 |       parse_rfc_822_sharepoint_bastard(date)
 81 |   end
 82 | 
 83 |   def parse_rfc_822(date) do
 84 |     case Timex.parse(date, "{RFC822}") do
 85 |       {:ok, date} ->
 86 |         date
 87 | 
 88 |       {:error, _} ->
 89 |         nil
 90 |     end
 91 |   end
 92 | 
 93 |   def parse_rfc_1123(date) do
 94 |     case Timex.parse(date, "{RFC1123}") do
 95 |       {:ok, date} ->
 96 |         date
 97 | 
 98 |       {:error, _} ->
 99 |         nil
100 |     end
101 |   end
102 | 
103 |   def parse_rfc_1123_published_on(date) do
104 |     case Timex.parse(date, "Published on {RFC1123}") do
105 |       {:ok, date} ->
106 |         date
107 | 
108 |       {:error, _} ->
109 |         nil
110 |     end
111 |   end
112 | 
113 |   def parse_rfc_822_sharepoint_bastard(date) do
114 |     case Timex.parse(date, "{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} {Zabbr}") do
115 |       {:ok, date} ->
116 |         date
117 | 
118 |       {:error, _} ->
119 |         nil
120 |     end
121 |   end
122 | 
123 |   defp put_title(struct, xml) do
124 |     struct(struct, title: xpath(xml, ~x"./title/text()"s))
125 |   end
126 | 
127 |   defp put_url(struct, xml) do
128 |     url = xpath(xml, ~x"./link/text()"so) || xpath(xml, ~x"./guid/text()"so) || ""
129 | 
130 |     struct(struct, url: url)
131 |   end
132 | 
133 |   defp put_author(struct, xml) do
134 |     author = xpath(xml, ~x"./author/text()"so) || xpath(xml, ~x"./dc:creator/text()"so)
135 | 
136 |     struct(struct, author: author)
137 |   end
138 | end
139 | 


--------------------------------------------------------------------------------
/lib/planet/core/feed_parser/sharepoint.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.FeedParser.Sharepoint do
 2 |   @moduledoc """
 3 |   This modules understands how to parse a feed from Microsoft Sharepoint.
 4 |   """
 5 |   alias PlanetEx.Core.FeedParser.{Rss}
 6 |   import SweetXml
 7 | 
 8 |   def parse(html) do
 9 |     html
10 |     |> xpath(~x"./body/rss"e)
11 |     |> Rss.parse()
12 |   end
13 | end
14 | 


--------------------------------------------------------------------------------
/lib/planet/core/feed_server.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.FeedServer do
 2 |   @moduledoc """
 3 |   FeedServer fetches, parses, and serves the feeds on a configurable schedule.
 4 |   """
 5 |   use GenServer
 6 |   require Logger
 7 |   alias PlanetEx.Core.FeedParser
 8 | 
 9 |   @fetcher Application.get_env(:planetex, :fetcher, PlanetEx.Core.FeedFetcher)
10 |   @timeout Application.get_env(:planetex, :server_timeout)
11 | 
12 |   def start_link(args) do
13 |     GenServer.start_link(__MODULE__, args)
14 |   end
15 | 
16 |   def status(server) do
17 |     GenServer.call(server, :status)
18 |   end
19 | 
20 |   def update(server, rss) do
21 |     GenServer.cast(server, {:update, rss})
22 |   end
23 | 
24 |   def put_feed(server, feed) do
25 |     GenServer.cast(server, {:put_feed, feed})
26 |   end
27 | 
28 |   def stop(server) do
29 |     GenServer.stop(server)
30 |   end
31 | 
32 |   def init(args) do
33 |     rss = Keyword.get(args, :rss)
34 |     timeout = Keyword.get(args, :timeout, @timeout)
35 | 
36 |     feed = build_feed(rss)
37 | 
38 |     schedule(timeout)
39 | 
40 |     {:ok, %{feed: feed, rss: rss, timeout: timeout}}
41 |   end
42 | 
43 |   def handle_call(:status, _f, state) do
44 |     {:reply, state.feed, state}
45 |   end
46 | 
47 |   def handle_cast({:update, updated_rss}, state) do
48 |     new_state = Map.put(state, :rss, updated_rss)
49 | 
50 |     {:noreply, new_state}
51 |   end
52 | 
53 |   def handle_cast({:put_feed, feed}, state) do
54 |     {:noreply, Map.put(state, :feed, feed)}
55 |   end
56 | 
57 |   def handle_info(:rebuild_feed, state) do
58 |     self()
59 |     |> fetch_and_build(state)
60 |     |> Task.start()
61 | 
62 |     schedule(state.timeout)
63 | 
64 |     {:noreply, state}
65 |   end
66 | 
67 |   defp schedule(timeout) do
68 |     Process.send_after(self(), :rebuild_feed, timeout)
69 |   end
70 | 
71 |   defp build_feed(rss) do
72 |     Logger.debug(fn -> "Rebuilding feed: #{inspect rss.url}" end)
73 | 
74 |     rss
75 |     |> @fetcher.get()
76 |     |> FeedParser.parse()
77 |   end
78 | 
79 |   defp fetch_and_build(server_pid, state) do
80 |     fn ->
81 |       put_feed(
82 |         server_pid,
83 |         build_feed(state.rss)
84 |       )
85 |     end
86 |   end
87 | end
88 | 


--------------------------------------------------------------------------------
/lib/planet/core/feed_store.ex:
--------------------------------------------------------------------------------
  1 | defmodule PlanetEx.Core.FeedStore do
  2 |   @moduledoc """
  3 |   This module is responsible for holding the PlanetEx feed.
  4 |   """
  5 |   alias PlanetEx.Core.FeedParser.Feed
  6 |   alias PlanetEx.Core.FeedServer
  7 |   alias PlanetEx.Core.ServerFarm
  8 | 
  9 |   use GenServer
 10 |   require Logger
 11 | 
 12 |   def start_link(args) do
 13 |     GenServer.start_link(__MODULE__, args, name: __MODULE__)
 14 |   end
 15 | 
 16 |   def status do
 17 |     GenServer.call(__MODULE__, :status)
 18 |   end
 19 | 
 20 |   def servers do
 21 |     GenServer.call(__MODULE__, :servers)
 22 |   end
 23 | 
 24 |   def push(feeds) when is_list(feeds) do
 25 |     GenServer.cast(__MODULE__, {:push, feeds})
 26 |   end
 27 | 
 28 |   def store(rss) do
 29 |     GenServer.cast(__MODULE__, {:store, rss})
 30 |   end
 31 | 
 32 |   def update(rss) do
 33 |     GenServer.cast(__MODULE__, {:update, rss})
 34 |   end
 35 | 
 36 |   def update_planet(planet) do
 37 |     GenServer.cast(__MODULE__, {:update_planet, planet})
 38 |   end
 39 | 
 40 |   def remove(rss) do
 41 |     GenServer.cast(__MODULE__, {:remove, rss})
 42 |   end
 43 | 
 44 |   def init(_args) do
 45 |     proc_table =
 46 |       PlanetEx.Feeds.list_rss()
 47 |       |> Enum.reduce(%{}, fn feed, acc ->
 48 |         {:ok, pid} = ServerFarm.plant(feed)
 49 | 
 50 |         Map.put(acc, feed.id, pid)
 51 |       end)
 52 | 
 53 |     our_planet = PlanetEx.Feeds.get_planet!(1)
 54 | 
 55 |     initial_feed = %Feed{
 56 |       title: our_planet.title,
 57 |       url: our_planet.url,
 58 |       author: our_planet.author
 59 |     }
 60 | 
 61 |     {:ok, %{feed: initial_feed, feed_servers: proc_table}}
 62 |   end
 63 | 
 64 |   def handle_call(:status, _f, state) do
 65 |     {:reply, state.feed, state}
 66 |   end
 67 | 
 68 |   def handle_call(:servers, _f, state) do
 69 |     {:reply, state.feed_servers, state}
 70 |   end
 71 | 
 72 |   def handle_cast({:push, feeds_to_merge}, %{feed: feed} = state) do
 73 |     merged_feed = Feed.merge(feeds_to_merge, feed)
 74 | 
 75 |     {:noreply, Map.put(state, :feed, merged_feed)}
 76 |   end
 77 | 
 78 |   def handle_cast({:store, new_rss}, %{feed_servers: feed_servers} = state) do
 79 |     {:ok, pid} = ServerFarm.plant(new_rss)
 80 | 
 81 |     feed_servers = Map.put(feed_servers, new_rss.id, pid)
 82 | 
 83 |     {:noreply, Map.put(state, :feed_servers, feed_servers)}
 84 |   end
 85 | 
 86 |   def handle_cast({:update, updated_rss}, %{feed_servers: feed_servers} = state) do
 87 |     server_pid = Map.fetch!(feed_servers, updated_rss.id)
 88 | 
 89 |     FeedServer.update(server_pid, updated_rss)
 90 | 
 91 |     {:noreply, state}
 92 |   end
 93 | 
 94 |   def handle_cast({:update_planet, updated_planet}, %{feed: feed} = state) do
 95 |     updated_feed = %Feed{
 96 |       title: updated_planet.title,
 97 |       url: updated_planet.url,
 98 |       author: updated_planet.author,
 99 |       entries: feed.entries
100 |     }
101 | 
102 |     {:noreply, Map.put(state, :feed, updated_feed)}
103 |   end
104 | 
105 |   def handle_cast({:remove, old_rss}, %{feed_servers: feed_servers} = state) do
106 |     {old_rss_pid, feed_servers} = Map.pop(feed_servers, old_rss.id)
107 | 
108 |     ServerFarm.reap(old_rss_pid)
109 | 
110 |     {:noreply, Map.put(state, :feed_servers, feed_servers)}
111 |   end
112 | end
113 | 


--------------------------------------------------------------------------------
/lib/planet/core/server_farm.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.ServerFarm do
 2 |   @moduledoc """
 3 |   This module handles supervising the farm of FeedServers.
 4 |   """
 5 |   use DynamicSupervisor
 6 |   alias PlanetEx.Core.FeedServer
 7 | 
 8 |   def start_link(_args) do
 9 |     DynamicSupervisor.start_link(__MODULE__, [], name: __MODULE__)
10 |   end
11 | 
12 |   def plant(feed) do
13 |     DynamicSupervisor.start_child(__MODULE__, %{
14 |       id: feed.id,
15 |       start: {FeedServer, :start_link, [[rss: feed]]}
16 |     })
17 |   end
18 | 
19 |   def reap(child_pid) do
20 |     DynamicSupervisor.terminate_child(__MODULE__, child_pid)
21 |   end
22 | 
23 |   @impl true
24 |   def init(_) do
25 |     DynamicSupervisor.init(strategy: :one_for_one)
26 |   end
27 | end
28 | 


--------------------------------------------------------------------------------
/lib/planet/core/server_farm_supervisor.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.ServerFarmSupervisor do
 2 |   @moduledoc """
 3 |   This modules supervises the process that fetch and serve the feeds.
 4 |   """
 5 |   use Supervisor
 6 |   alias PlanetEx.Core.Cron
 7 |   alias PlanetEx.Core.FeedServer
 8 |   alias PlanetEx.Core.FeedStore
 9 |   alias PlanetEx.Core.ServerFarm
10 | 
11 |   require Logger
12 | 
13 |   def start_link(arg) do
14 |     Supervisor.start_link(__MODULE__, arg, name: __MODULE__)
15 |   end
16 | 
17 |   def init(_arg) do
18 |     children = [
19 |       ServerFarm,
20 |       FeedStore,
21 |       refresh_feed_store_job(),
22 |       write_feed_to_disk_job()
23 |     ]
24 | 
25 |     Supervisor.init(children, strategy: :one_for_one)
26 |   end
27 | 
28 |   defp refresh_feed_store_job do
29 |     Supervisor.child_spec(
30 |       {
31 |         Cron,
32 |         fn ->
33 |           feed_servers = FeedStore.servers()
34 | 
35 |           feeds =
36 |             for pid <- Map.values(feed_servers) do
37 |               FeedServer.status(pid)
38 |             end
39 | 
40 |           FeedStore.push(feeds)
41 |         end
42 |       },
43 |       id: {Cron, :refresher}
44 |     )
45 |   end
46 | 
47 |   defp write_feed_to_disk_job do
48 |     Supervisor.child_spec(
49 |       {
50 |         Cron,
51 |         fn ->
52 |           feed = FeedStore.status()
53 | 
54 |           Logger.debug(fn -> "Writing feed.xml" end)
55 | 
56 |           File.write!(
57 |             Application.app_dir(:planetex, "priv/static/feed.xml"),
58 |             Phoenix.View.render_to_iodata(PlanetExWeb.RssView, "feed.xml", feed: feed)
59 |           )
60 |         end
61 |       },
62 |       id: {Cron, :feed_writer}
63 |     )
64 |   end
65 | end
66 | 


--------------------------------------------------------------------------------
/lib/planet/feeds/feeds.ex:
--------------------------------------------------------------------------------
  1 | defmodule PlanetEx.Feeds do
  2 |   @moduledoc """
  3 |   The Feeds context.
  4 |   """
  5 | 
  6 |   import Ecto.Query, warn: false
  7 |   alias PlanetEx.Repo
  8 | 
  9 |   alias PlanetEx.Feeds.Rss
 10 | 
 11 |   @doc """
 12 |   Returns the list of rss.
 13 | 
 14 |   ## Examples
 15 | 
 16 |       iex> list_rss()
 17 |       [%Rss{}, ...]
 18 | 
 19 |   """
 20 |   def list_rss do
 21 |     Repo.all(Rss)
 22 |   end
 23 | 
 24 |   @doc """
 25 |   Gets a single rss.
 26 | 
 27 |   Raises `Ecto.NoResultsError` if the Rss does not exist.
 28 | 
 29 |   ## Examples
 30 | 
 31 |       iex> get_rss!(123)
 32 |       %Rss{}
 33 | 
 34 |       iex> get_rss!(456)
 35 |       ** (Ecto.NoResultsError)
 36 | 
 37 |   """
 38 |   def get_rss!(id), do: Repo.get!(Rss, id)
 39 | 
 40 |   @doc """
 41 |   Gets a single rss.
 42 | 
 43 |   ## Examples
 44 | 
 45 |       iex> get_rss(123)
 46 |       {:ok, %Rss{}}
 47 | 
 48 |       iex> get_rss(456)
 49 |       {:error, %Ecto.Changeset{}}
 50 | 
 51 |   """
 52 |   def get_rss(id), do: Repo.get(Rss, id)
 53 | 
 54 |   @doc """
 55 |   Creates a rss.
 56 | 
 57 |   ## Examples
 58 | 
 59 |       iex> create_rss(%{field: value})
 60 |       {:ok, %Rss{}}
 61 | 
 62 |       iex> create_rss(%{field: bad_value})
 63 |       {:error, %Ecto.Changeset{}}
 64 | 
 65 |   """
 66 |   def create_rss(attrs \\ %{}) do
 67 |     %Rss{}
 68 |     |> Rss.changeset(attrs)
 69 |     |> Repo.insert()
 70 |   end
 71 | 
 72 |   @doc """
 73 |   Updates a rss.
 74 | 
 75 |   ## Examples
 76 | 
 77 |       iex> update_rss(rss, %{field: new_value})
 78 |       {:ok, %Rss{}}
 79 | 
 80 |       iex> update_rss(rss, %{field: bad_value})
 81 |       {:error, %Ecto.Changeset{}}
 82 | 
 83 |   """
 84 |   def update_rss(%Rss{} = rss, attrs) do
 85 |     rss
 86 |     |> Rss.changeset(attrs)
 87 |     |> Repo.update()
 88 |   end
 89 | 
 90 |   @doc """
 91 |   Deletes a Rss.
 92 | 
 93 |   ## Examples
 94 | 
 95 |       iex> delete_rss(rss)
 96 |       {:ok, %Rss{}}
 97 | 
 98 |       iex> delete_rss(rss)
 99 |       {:error, %Ecto.Changeset{}}
100 | 
101 |   """
102 |   def delete_rss(%Rss{} = rss) do
103 |     Repo.delete(rss)
104 |   end
105 | 
106 |   @doc """
107 |   Returns an `%Ecto.Changeset{}` for tracking rss changes.
108 | 
109 |   ## Examples
110 | 
111 |       iex> change_rss(rss)
112 |       %Ecto.Changeset{source: %Rss{}}
113 | 
114 |   """
115 |   def change_rss(%Rss{} = rss) do
116 |     Rss.changeset(rss, %{})
117 |   end
118 | 
119 |   alias PlanetEx.Feeds.Planet
120 | 
121 |   @doc """
122 |   Gets a single planet.
123 | 
124 |   Raises `Ecto.NoResultsError` if the Planets does not exist.
125 | 
126 |   ## Examples
127 | 
128 |       iex> get_planet!(123)
129 |       %Planet{}
130 | 
131 |       iex> get_planet!(456)
132 |       ** (Ecto.NoResultsError)
133 | 
134 |   """
135 |   def get_planet!(id), do: Repo.get!(Planet, id)
136 | 
137 |   @doc """
138 |   Updates a planet.
139 | 
140 |   ## Examples
141 | 
142 |       iex> update_planet(planets, %{field: new_value})
143 |       {:ok, %Planet{}}
144 | 
145 |       iex> update_planet(planet, %{field: bad_value})
146 |       {:error, %Ecto.Changeset{}}
147 | 
148 |   """
149 |   def update_planet(%Planet{} = planet, attrs) do
150 |     planet
151 |     |> Planet.changeset(attrs)
152 |     |> Repo.update()
153 |   end
154 | 
155 |   @doc """
156 |   Returns an `%Ecto.Changeset{}` for tracking planet changes.
157 | 
158 |   ## Examples
159 | 
160 |       iex> change_planets(planet)
161 |       %Ecto.Changeset{source: %Planet{}}
162 | 
163 |   """
164 |   def change_planet(%Planet{} = planet) do
165 |     Planet.changeset(planet, %{})
166 |   end
167 | end
168 | 


--------------------------------------------------------------------------------
/lib/planet/feeds/planet.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Feeds.Planet do
 2 |   @moduledoc """
 3 |   This schema describes the aggregated feed displayed on the home page. This is a singleton.
 4 |   """
 5 |   use Ecto.Schema
 6 |   import Ecto.Changeset
 7 | 
 8 |   schema "planets" do
 9 |     field :author, :string
10 |     field :title, :string
11 |     field :url, :string
12 | 
13 |     timestamps()
14 |   end
15 | 
16 |   @doc false
17 |   def changeset(planets, attrs) do
18 |     planets
19 |     |> cast(attrs, [:title, :url, :author])
20 |     |> validate_required([:title, :url, :author])
21 |   end
22 | end
23 | 


--------------------------------------------------------------------------------
/lib/planet/feeds/rss.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Feeds.Rss do
 2 |   @moduledoc """
 3 |   This module provides the schema for the RSS domain concept.
 4 | 
 5 |   Each RSS struct represents an RSS, Atom, or Sharepoint feed.
 6 |   """
 7 |   use Ecto.Schema
 8 |   import Ecto.Changeset
 9 | 
10 |   schema "rss" do
11 |     field :author, :string
12 |     field :name, :string
13 |     field :url, :string
14 |     field :is_sharepoint, :boolean
15 | 
16 |     timestamps()
17 |   end
18 | 
19 |   @doc false
20 |   def changeset(rss, attrs \\ %{}) do
21 |     rss
22 |     |> cast(attrs, [:name, :url, :author, :is_sharepoint])
23 |     |> validate_required([:name, :url, :author, :is_sharepoint])
24 |     |> unique_constraint(:url, message: "this feed has already been added.")
25 |   end
26 | end
27 | 


--------------------------------------------------------------------------------
/lib/planet/release_tasks.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.ReleaseTasks do
 2 |   @moduledoc """
 3 |   This module is used to define post release tasks such as database migrations.
 4 |   """
 5 |   @start_apps [
 6 |     :crypto,
 7 |     :ssl,
 8 |     :postgrex,
 9 |     :ecto
10 |   ]
11 | 
12 |   @repos Application.get_env(:planetex, :ecto_repos, [])
13 | 
14 |   def migrate(_argv) do
15 |     start_services()
16 | 
17 |     run_migrations()
18 | 
19 |     stop_services()
20 |   end
21 | 
22 |   def seed(_argv) do
23 |     start_services()
24 | 
25 |     run_migrations()
26 | 
27 |     run_seeds()
28 | 
29 |     stop_services()
30 |   end
31 | 
32 |   defp start_services do
33 |     IO.puts("Starting dependencies..")
34 |     # Start apps necessary for executing migrations
35 |     Enum.each(@start_apps, &Application.ensure_all_started/1)
36 | 
37 |     # Start the Repo(s) for app
38 |     IO.puts("Starting repos..")
39 |     Enum.each(@repos, & &1.start_link(pool_size: 1))
40 |   end
41 | 
42 |   defp stop_services do
43 |     IO.puts("Success!")
44 |     :init.stop()
45 |   end
46 | 
47 |   defp run_migrations do
48 |     Enum.each(@repos, &run_migrations_for/1)
49 |   end
50 | 
51 |   defp run_migrations_for(repo) do
52 |     app = Keyword.get(repo.config, :otp_app)
53 |     IO.puts("Running migrations for #{app}")
54 |     migrations_path = priv_path_for(repo, "migrations")
55 |     Ecto.Migrator.run(repo, migrations_path, :up, all: true)
56 |   end
57 | 
58 |   defp run_seeds do
59 |     Enum.each(@repos, &run_seeds_for/1)
60 |   end
61 | 
62 |   defp run_seeds_for(repo) do
63 |     # Run the seed script if it exists
64 |     seed_script = priv_path_for(repo, "seeds.exs")
65 | 
66 |     if File.exists?(seed_script) do
67 |       IO.puts("Running seed script..")
68 |       Code.eval_file(seed_script)
69 |     end
70 |   end
71 | 
72 |   defp priv_path_for(repo, filename) do
73 |     app = Keyword.get(repo.config, :otp_app)
74 | 
75 |     repo_underscore =
76 |       repo
77 |       |> Module.split()
78 |       |> List.last()
79 |       |> Macro.underscore()
80 | 
81 |     priv_dir = "#{:code.priv_dir(app)}"
82 | 
83 |     Path.join([priv_dir, repo_underscore, filename])
84 |   end
85 | end
86 | 


--------------------------------------------------------------------------------
/lib/planet/repo.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Repo do
 2 |   use Ecto.Repo, otp_app: :planetex
 3 | 
 4 |   @doc """
 5 |   Dynamically loads the repository url from the
 6 |   DATABASE_URL environment variable.
 7 |   """
 8 |   def init(_, config) do
 9 |     if config[:load_from_system_env] do
10 |       config =
11 |         config
12 |         |> Keyword.put(:url, System.get_env("DATABASE_URL"))
13 |         |> Keyword.put(:pool_size, String.to_integer(System.get_env("POOL_SIZE") || "18"))
14 | 
15 |       {:ok, config}
16 |     else
17 |       {:ok, config}
18 |     end
19 |   end
20 | end
21 | 


--------------------------------------------------------------------------------
/lib/planet_web.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb do
 2 |   @moduledoc """
 3 |   The entrypoint for defining your web interface, such
 4 |   as controllers, views, channels and so on.
 5 | 
 6 |   This can be used in your application as:
 7 | 
 8 |       use PlanetExWeb, :controller
 9 |       use PlanetExWeb, :view
10 | 
11 |   The definitions below will be executed for every view,
12 |   controller, etc, so keep them short and clean, focused
13 |   on imports, uses and aliases.
14 | 
15 |   Do NOT define functions inside the quoted expressions
16 |   below. Instead, define any helper function in modules
17 |   and import those modules here.
18 |   """
19 | 
20 |   def controller do
21 |     quote do
22 |       use Phoenix.Controller, namespace: PlanetExWeb
23 |       import Plug.Conn
24 |       import PlanetExWeb.Router.Helpers
25 |       import PlanetExWeb.Gettext
26 |     end
27 |   end
28 | 
29 |   def view do
30 |     quote do
31 |       use Phoenix.View,
32 |         root: "lib/planet_web/templates",
33 |         namespace: PlanetExWeb
34 | 
35 |       # Import convenience functions from controllers
36 |       import Phoenix.Controller, only: [get_flash: 1, view_module: 1]
37 | 
38 |       # Use all HTML functionality (forms, tags, etc)
39 |       use Phoenix.HTML
40 | 
41 |       import PlanetExWeb.Router.Helpers
42 |       import PlanetExWeb.ErrorHelpers
43 |       import PlanetExWeb.Gettext
44 |     end
45 |   end
46 | 
47 |   def router do
48 |     quote do
49 |       use Phoenix.Router
50 |       import Plug.Conn
51 |       import Phoenix.Controller
52 |     end
53 |   end
54 | 
55 |   def channel do
56 |     quote do
57 |       use Phoenix.Channel
58 |       import PlanetExWeb.Gettext
59 |     end
60 |   end
61 | 
62 |   @doc """
63 |   When used, dispatch to the appropriate controller/view/etc.
64 |   """
65 |   defmacro __using__(which) when is_atom(which) do
66 |     apply(__MODULE__, which, [])
67 |   end
68 | end
69 | 


--------------------------------------------------------------------------------
/lib/planet_web/channels/user_socket.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.UserSocket do
 2 |   use Phoenix.Socket
 3 | 
 4 |   ## Channels
 5 |   # channel "room:*", PlanetExWeb.RoomChannel
 6 | 
 7 |   ## Transports
 8 |   transport :websocket, Phoenix.Transports.WebSocket
 9 |   # transport :longpoll, Phoenix.Transports.LongPoll
10 | 
11 |   # Socket params are passed from the client and can
12 |   # be used to verify and authenticate a user. After
13 |   # verification, you can put default assigns into
14 |   # the socket that will be set for all channels, ie
15 |   #
16 |   #     {:ok, assign(socket, :user_id, verified_user_id)}
17 |   #
18 |   # To deny connection, return `:error`.
19 |   #
20 |   # See `Phoenix.Token` documentation for examples in
21 |   # performing token verification on connect.
22 |   def connect(_params, socket) do
23 |     {:ok, socket}
24 |   end
25 | 
26 |   # Socket id's are topics that allow you to identify all sockets for a given user:
27 |   #
28 |   #     def id(socket), do: "user_socket:#{socket.assigns.user_id}"
29 |   #
30 |   # Would allow you to broadcast a "disconnect" event and terminate
31 |   # all active sockets and channels for a given user:
32 |   #
33 |   #     PlanetExWeb.Endpoint.broadcast("user_socket:#{user.id}", "disconnect", %{})
34 |   #
35 |   # Returning `nil` makes this socket anonymous.
36 |   def id(_socket), do: nil
37 | end
38 | 


--------------------------------------------------------------------------------
/lib/planet_web/controllers/entries_controller.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.EntriesController do
 2 |   use PlanetExWeb, :controller
 3 |   alias PlanetEx.Core.FeedParser.Feed
 4 |   alias PlanetEx.Core.FeedStore
 5 | 
 6 |   def index(conn, %{"page" => page}) do
 7 |     conn
 8 |     |> fetch_and_render_entries(String.to_integer(page))
 9 |   end
10 | 
11 |   def index(conn, _p) do
12 |     conn
13 |     |> fetch_and_render_entries(1)
14 |   end
15 | 
16 |   defp fetch_and_render_entries(conn, page) do
17 |     feed = FeedStore.status()
18 | 
19 |     chunked = Enum.chunk_every(feed.entries, 10)
20 |     entries = chunked |> Enum.at(page - 1, [])
21 |     pages = length(chunked)
22 | 
23 |     feed = %Feed{
24 |       feed
25 |       | entries: entries
26 |     }
27 | 
28 |     conn
29 |     |> render(:index, feed: feed, page: page, pages: pages)
30 |   end
31 | end
32 | 


--------------------------------------------------------------------------------
/lib/planet_web/controllers/planet_controller.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.PlanetController do
 2 |   use PlanetExWeb, :controller
 3 | 
 4 |   alias PlanetEx.Feeds
 5 | 
 6 |   def edit(conn, %{"id" => id}) do
 7 |     planet = Feeds.get_planet!(id)
 8 |     changeset = Feeds.change_planet(planet)
 9 |     render(conn, "edit.html", planet: planet, changeset: changeset)
10 |   end
11 | 
12 |   def update(conn, %{"id" => id, "planet" => planet_params}) do
13 |     planet = Feeds.get_planet!(id)
14 | 
15 |     with {:ok, updated_planet = %Feeds.Planet{}} <- Feeds.update_planet(planet, planet_params),
16 |          PlanetEx.Core.FeedStore.update_planet(updated_planet) do
17 |       conn
18 |       |> put_flash(:success, "Planet updated successfully.")
19 |       |> redirect(to: entries_path(conn, :index))
20 |     else
21 |       {:error, %Ecto.Changeset{} = changeset} ->
22 |         conn
23 |         |> put_flash(:danger, "Planet failed to update.")
24 |         |> render("edit.html", planet: planet, changeset: changeset)
25 |     end
26 |   end
27 | end
28 | 


--------------------------------------------------------------------------------
/lib/planet_web/controllers/rss_controller.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.RssController do
 2 |   use PlanetExWeb, :controller
 3 |   alias PlanetEx.Feeds.Rss
 4 | 
 5 |   def index(conn, _p) do
 6 |     with feeds <- PlanetEx.Feeds.list_rss() |> Enum.sort_by(fn f -> f.name end) do
 7 |       conn
 8 |       |> render(:index, feeds: feeds)
 9 |     end
10 |   end
11 | 
12 |   def create conn, %{"rss" => params} do
13 |     with {:ok, feed = %Rss{}} <- PlanetEx.Feeds.create_rss(params),
14 |          PlanetEx.Core.FeedStore.store(feed) do
15 |       conn
16 |       |> put_status(303)
17 |       |> put_flash(:success, "You've add the feed #{feed.url}")
18 |       |> redirect(to: "/rss/new")
19 |     else
20 |       {:error, changeset} ->
21 |         conn
22 |         |> put_status(400)
23 |         |> render_form(:new, changeset)
24 |     end
25 |   end
26 | 
27 |   def new(conn, _p) do
28 |     render_form(conn, :new, %Rss{})
29 |   end
30 | 
31 |   def edit(conn, %{"id" => id}) do
32 |     with feed = %Rss{} <- PlanetEx.Feeds.get_rss!(id) do
33 |       conn
34 |       |> render_form(:edit, feed)
35 |     end
36 |   end
37 | 
38 |   def update(conn, %{"id" => id, "rss" => params}) do
39 |     feed = PlanetEx.Feeds.get_rss!(id)
40 | 
41 |     with {:ok, updated_feed = %Rss{}} <- PlanetEx.Feeds.update_rss(feed, params),
42 |          PlanetEx.Core.FeedStore.update(updated_feed) do
43 |       conn
44 |       |> put_status(303)
45 |       |> put_flash(:success, "You've updated the feed #{updated_feed.name}")
46 |       |> redirect(to: "/rss")
47 |     else
48 |       {:error, changeset} ->
49 |         conn
50 |         |> put_status(400)
51 |         |> render_form(:edit, changeset)
52 |     end
53 |   end
54 | 
55 |   def delete(conn, %{"id" => id}) do
56 |     with %Rss{} = feed <- PlanetEx.Feeds.get_rss(id),
57 |          {:ok, deleted_feed} <- PlanetEx.Feeds.delete_rss(feed),
58 |          PlanetEx.Core.FeedStore.remove(deleted_feed) do
59 |       conn
60 |       |> put_status(303)
61 |       |> put_flash(:success, "You've deleted the feed #{deleted_feed.name}")
62 |       |> redirect(to: "/rss")
63 |     else
64 |       _ ->
65 |         conn
66 |         |> put_status(303)
67 |         |> put_flash(:danger, "Failed to delete that feed!")
68 |         |> redirect(to: "/rss")
69 |     end
70 |   end
71 | 
72 |   defp render_form(conn, action, rss) do
73 |     rss_changeset = Rss.changeset(rss)
74 | 
75 |     render conn, action, rss_changeset: rss_changeset
76 |   end
77 | end
78 | 


--------------------------------------------------------------------------------
/lib/planet_web/endpoint.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.Endpoint do
 2 |   use Phoenix.Endpoint, otp_app: :planetex
 3 | 
 4 |   socket "/socket", PlanetExWeb.UserSocket
 5 | 
 6 |   # Wallaby configuration
 7 |   if Application.get_env(:planetex, :sql_sandbox) do
 8 |     plug Phoenix.Ecto.SQL.Sandbox
 9 |   end
10 | 
11 |   # Serve at "/" the static files from "priv/static" directory.
12 |   #
13 |   # You should set gzip to true if you are running phoenix.digest
14 |   # when deploying your static files in production.
15 |   plug Plug.Static,
16 |     at: "/",
17 |     from: :planetex,
18 |     gzip: false,
19 |     only: ~w(css fonts images js robots.txt feed.xml),
20 |     only_matching: ~w(favicon)
21 | 
22 |   # Code reloading can be explicitly enabled under the
23 |   # :code_reloader configuration of your endpoint.
24 |   if code_reloading? do
25 |     socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket
26 |     plug Phoenix.LiveReloader
27 |     plug Phoenix.CodeReloader
28 |   end
29 | 
30 |   plug Plug.Logger
31 | 
32 |   plug Plug.Parsers,
33 |     parsers: [:urlencoded, :multipart, :json],
34 |     pass: ["*/*"],
35 |     json_decoder: Poison
36 | 
37 |   plug Plug.MethodOverride
38 |   plug Plug.Head
39 | 
40 |   # The session will be stored in the cookie and signed,
41 |   # this means its contents can be read but not tampered with.
42 |   # Set :encryption_salt if you would also like to encrypt it.
43 |   plug Plug.Session,
44 |     store: :cookie,
45 |     key: "_planet_key",
46 |     signing_salt: "YamjpzQ6"
47 | 
48 |   plug PlanetExWeb.Router
49 | 
50 |   @doc """
51 |   Callback invoked for dynamically configuring the endpoint.
52 | 
53 |   It receives the endpoint configuration and checks if
54 |   configuration should be loaded from the system environment.
55 |   """
56 |   def init(_key, config) do
57 |     if config[:load_from_system_env] do
58 |       port = System.get_env("PORT") || raise "expected the PORT environment variable to be set"
59 | 
60 |       config =
61 |         config
62 |         |> Keyword.put(:http, [:inet6, port: port])
63 |         |> Keyword.put(:secret_key_base, System.get_env("SECRET_KEY_BASE"))
64 |         |> Keyword.put(:url, scheme: "http", host: System.get_env("DOMAIN"), port: 80)
65 | 
66 |       {:ok, config}
67 |     else
68 |       {:ok, config}
69 |     end
70 |   end
71 | end
72 | 


--------------------------------------------------------------------------------
/lib/planet_web/gettext.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.Gettext do
 2 |   @moduledoc """
 3 |   A module providing Internationalization with a gettext-based API.
 4 | 
 5 |   By using [Gettext](https://hexdocs.pm/gettext),
 6 |   your module gains a set of macros for translations, for example:
 7 | 
 8 |       import PlanetExWeb.Gettext
 9 | 
10 |       # Simple translation
11 |       gettext "Here is the string to translate"
12 | 
13 |       # Plural translation
14 |       ngettext "Here is the string to translate",
15 |                "Here are the strings to translate",
16 |                3
17 | 
18 |       # Domain-based translation
19 |       dgettext "errors", "Here is the error message to translate"
20 | 
21 |   See the [Gettext Docs](https://hexdocs.pm/gettext) for detailed usage.
22 |   """
23 |   use Gettext, otp_app: :planetex
24 | end
25 | 


--------------------------------------------------------------------------------
/lib/planet_web/router.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.Router do
 2 |   use PlanetExWeb, :router
 3 | 
 4 |   pipeline :browser do
 5 |     plug :accepts, ["html"]
 6 |     plug :fetch_session
 7 |     plug :fetch_flash
 8 |     plug :protect_from_forgery
 9 |     plug :put_secure_browser_headers
10 |   end
11 | 
12 |   pipeline :api do
13 |     plug :accepts, ["json"]
14 |   end
15 | 
16 |   scope "/", PlanetExWeb do
17 |     pipe_through :browser
18 | 
19 |     get "/", EntriesController, :index
20 |     resources "/rss", RssController
21 |     resources "/planets", PlanetController, only: [:edit, :update]
22 |   end
23 | end
24 | 


--------------------------------------------------------------------------------
/lib/planet_web/templates/entries/index.html.eex:
--------------------------------------------------------------------------------
 1 | <h1 class="text-center mb-8"><%= @feed.title %></h1>
 2 | 
 3 | <div class="max-w-lg mx-auto">
 4 |   <%= for entry <- @feed.entries do %>
 5 |     <article class="post pb-8 mb-12 border-green-lighter border-b">
 6 |       <div class="xs:text-3xl sm:text-4xl mb-4"><a href="<%= entry.url %>"><%= entry.title %></a></div>
 7 |       <div class="xs:text-lg text-2xl font-bold">By <%= entry.author %> on <%= Timex.format!(entry.published, "{M}/{D}/{YYYY}") %></div>
 8 | 
 9 |       <p><%= raw entry.content %></p>
10 |     </article>
11 |   <% end %>
12 | 
13 |   <div class="flex justify-between items-center mb-4">
14 |     <a href="<%= "/?page=#{@page - 1}" %>"
15 |        class="text-white bg-green text-lg py-2 px-4 mr-2 hover:no-underline rounded-full border border-green
16 |        <%= unless @page > 1 do %>
17 |          invisible     
18 |        <% end %>
19 |        ">
20 |        Prev
21 |     </a>
22 |     <div class="text-green font-bold text-lg"><%= @page %></div>
23 |     <a href="<%= "/?page=#{@page + 1}" %>"
24 |        class="text-white bg-green text-lg py-2 px-4 ml-2 hover:no-underline rounded-full border border-green
25 |        <%= unless @page < @pages do %>
26 |          invisible
27 |        <% end %>
28 |        ">
29 |        Next
30 |     </a>
31 |   </div>
32 | </div>
33 | 


--------------------------------------------------------------------------------
/lib/planet_web/templates/layout/_head.html.eex:
--------------------------------------------------------------------------------
 1 | <head>
 2 |   <meta charset="utf-8">
 3 |   <meta http-equiv="X-UA-Compatible" content="IE=edge">
 4 |   <meta name="viewport" content="width=device-width, initial-scale=1">
 5 |   <meta name="description" content="">
 6 |   <meta name="author" content="">
 7 | 
 8 |   <title>Planet</title> 
 9 |   <link rel="shortcut icon" href="<%= static_path(@conn, "/favicon.ico") %>" type="image/x-icon">
10 |   <link rel="icon" href="<%= static_path(@conn, "/favicon.ico") %>" type="image/x-icon">
11 |   <link rel="stylesheet" href="<%= static_path(@conn, "/css/app.css") %>">
12 | 
13 |   <script src="<%= static_path(@conn, "/js/app.js") %>"></script>
14 |   <script>PlanetEx = require("js/app").PlanetEx</script>
15 | </head>
16 | 


--------------------------------------------------------------------------------
/lib/planet_web/templates/layout/_header.html.eex:
--------------------------------------------------------------------------------
 1 | <header class="flex justify-between items-center py-4">
 2 |   <a href="/">
 3 |     <svg class="fill-current text-green inline-block h-8 w-8" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20"><path d="M10 20a10 10 0 1 1 0-20 10 10 0 0 1 0 20zm2-2.25a8 8 0 0 0 4-2.46V9a2 2 0 0 1-2-2V3.07a7.95 7.95 0 0 0-3-1V3a2 2 0 0 1-2 2v1a2 2 0 0 1-2 2v2h3a2 2 0 0 1 2 2v5.75zm-4 0V15a2 2 0 0 1-2-2v-1h-.5A1.5 1.5 0 0 1 4 10.5V8H2.25A8.01 8.01 0 0 0 8 17.75z"/></svg>
 4 |   </a>
 5 |   <span class="flex justify-end">
 6 |     <a class="text-xl no-underline hover:underline" href="/planets/1/edit">Our Planet</a>
 7 |     <a class="text-xl no-underline hover:underline ml-4" href="/rss">Feeds</a>
 8 |   </span>
 9 | </header>
10 | 


--------------------------------------------------------------------------------
/lib/planet_web/templates/layout/app.html.eex:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <%= render PlanetExWeb.LayoutView, "_head.html", conn: @conn%>
 4 | 
 5 |   <body class="border-green border-t-7 font-sans">
 6 |     <div class="container px-4">
 7 |       <%= render PlanetExWeb.LayoutView, "_header.html" %>
 8 |       <%= case get_flash(@conn) do %>
 9 |         <% %{"success" => message} -> %>
10 |           <div class="bg-green-lightest border-l-4 border-green text-green-dark p-4" role="alert">
11 |             <p class="font-bold">Success!</p>
12 |             <p><%= message %></p>
13 |           </div>
14 | 
15 |         <% %{"danger" => message} -> %>
16 |           <div class="bg-red-lightest border-l-4 border-red text-red-dark p-4" role="alert">
17 |             <p class="font-bold">Oh no!</p>
18 |             <p><%= message %></p>
19 |           </div>
20 | 
21 |         <% _-> %>
22 |       <% end %>
23 | 
24 |       <main role="main">
25 |         <%= render @view_module, @view_template, assigns %>
26 |       </main>
27 |     </div>
28 |   </body>
29 | </html>
30 | 


--------------------------------------------------------------------------------
/lib/planet_web/templates/planet/_form.html.eex:
--------------------------------------------------------------------------------
 1 | <%= form_for @changeset, @action, [onsubmit: "PlanetEx.disableSubmitButton()", class: "max-w-xs-sm mx-auto"], fn(f) -> %>
 2 |   <div class="flex flex-col">
 3 |     <%= label f, :title, [class: "text-label-grey opacity-75"] do %>
 4 |       Title 
 5 |       <%= error_tag f, :title %>
 6 |     <% end %>
 7 |     <%= text_input f, :title, [class: "bg-green-ultimate-light p-3 mt-2 mb-4 soft-placeholder green-focus", required: true, placeholder: "Our Planet Roll"] %>
 8 | 
 9 |     <%= label f, :url, [class: "text-label-grey opacity-75"] do %>
10 |       URL
11 |       <%= error_tag f, :url %>
12 |     <% end %>
13 |     <%= url_input f, :url, [class: "bg-green-ultimate-light p-3 mt-2 mb-4 soft-placeholder green-focus", required: true, placeholder: "Our Planet URL"] %>
14 | 
15 |     <%= label f, :author, [class: "text-label-grey opacity-75"] do %>
16 |       Author
17 |       <%= error_tag f, :author %>
18 |     <% end %>
19 |     <%= text_input f, :author, [class: "bg-green-ultimate-light p-3 mt-2 mb-4 soft-placeholder green-focus", required: true, placeholder: "Planeteers"] %>
20 |   </div>
21 | 
22 |   <div class="flex justify-between mt-4">
23 |     <button id="submitButton" type="submit" class="bg-green hover:bg-green-dark text-xl text-white px-8 py-2 rounded-full">
24 |       Update
25 |     </button>
26 |     <a href="/" class="bg-white hover:bg-red-light text-xl text-grey hover:text-white px-8 py-2 rounded-full hover:no-underline">
27 |       Cancel
28 |     </a>
29 |   </div>
30 | <% end %>
31 | 
32 | 


--------------------------------------------------------------------------------
/lib/planet_web/templates/planet/edit.html.eex:
--------------------------------------------------------------------------------
1 | <div class="max-w-sm mx-auto">
2 |   <div class="text-5xl font-light text-center">Our Planet</div>
3 |   <hr class="w-full h-px bg-green-lightest mb-8">
4 | </div>
5 | 
6 | <%= render "_form.html", Map.put(assigns, :action, planet_path(@conn, :update, @planet)) %>
7 | 


--------------------------------------------------------------------------------
/lib/planet_web/templates/rss/_form.html.eex:
--------------------------------------------------------------------------------
 1 | <%= form_for @rss_changeset, @action, [onsubmit: "PlanetEx.disableSubmitButton()", class: "max-w-xs-sm mx-auto"], fn(f) -> %>
 2 |   <div class="flex flex-col">
 3 |     <%= label f, :name, [class: "text-label-grey opacity-75"] do %>
 4 |       Name 
 5 |       <%= error_tag f, :name %>
 6 |     <% end %>
 7 |     <%= text_input f, :name, [class: "bg-green-ultimate-light p-3 mt-2 mb-4 soft-placeholder green-focus", required: true, placeholder: "SEP Blog"] %>
 8 | 
 9 |     <%= label f, :url, [class: "text-label-grey opacity-75"] do %>
10 |       URL
11 |       <%= error_tag f, :url %>
12 |     <% end %>
13 |     <%= url_input f, :url, [class: "bg-green-ultimate-light p-3 mt-2 mb-4 soft-placeholder green-focus", required: true, placeholder: "https://www.sep.com/sep-blog/feed"] %>
14 | 
15 |     <%= label f, :author, [class: "text-label-grey opacity-75"] do %>
16 |       Author
17 |       <%= error_tag f, :author %>
18 |     <% end %>
19 |     <%= text_input f, :author, [class: "bg-green-ultimate-light p-3 mt-2 mb-4 soft-placeholder green-focus", required: true, placeholder: "SEPeers"] %>
20 | 
21 |     <div class="flex">
22 |       <%= checkbox f, :is_sharepoint, [class: "mr-4"] %>
23 |       <%= label f, :is_sharepoint, [class: "text-label-grey opacity-75"] do %>
24 |         Sharepoint?
25 |         <%= error_tag f, :is_sharepoint %>
26 |       <% end %>
27 |     </div>
28 |   </div>
29 | 
30 |   <div class="flex justify-between mt-4">
31 |     <button id="submitButton" type="submit" class="bg-green hover:bg-green-dark text-xl text-white px-8 py-2 rounded-full">
32 |       <%= @button_text %>
33 |     </button>
34 |     <a href="/rss" class="bg-white hover:bg-red-light text-xl text-grey hover:text-white px-8 py-2 rounded-full hover:no-underline">
35 |       Cancel
36 |     </a>
37 |   </div>
38 | <% end %>
39 | 
40 | 


--------------------------------------------------------------------------------
/lib/planet_web/templates/rss/edit.html.eex:
--------------------------------------------------------------------------------
1 | <div class="text-center mt-2 mb-12">
2 |   <span class="text-4xl md:text-5xl font-light">Edit an <strong>RSS</strong> Feed</span>
3 | </div>
4 | 
5 | <%= render PlanetExWeb.RssView, "_form.html", Map.merge(assigns, %{action: rss_path(@conn, :update, @rss_changeset.data.id), button_text: "Update"}) %>
6 | 


--------------------------------------------------------------------------------
/lib/planet_web/templates/rss/feed.xml.eex:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <feed xmlns="http://www.w3.org/2005/Atom">
 3 |   <title><%= @feed.title %></title>
 4 |   <link href="<%= @feed.url %>"/>
 5 |   <updated><%= last_updated_at(@feed) %></updated>
 6 |   <author>
 7 |     <name><%= @feed.author %></name>
 8 |   </author>
 9 |   <id><%= @feed.url %></id>
10 | 
11 |   <%= for entry <- @feed.entries do %>
12 |     <entry>
13 |       <title type="text"><%= escape(entry.title) %></title>
14 |       <author>
15 |         <name><%= escape(entry.author) %></name>
16 |       </author>
17 |       <link href="<%= entry.url %>"/>
18 |       <id><%= entry.url %></id>
19 |       <updated><%= published(entry.published) %></updated>
20 |       <content type="html"><%= escape(entry.content) %></content>
21 |     </entry>
22 |   <% end %>
23 | </feed>
24 | 


--------------------------------------------------------------------------------
/lib/planet_web/templates/rss/index.html.eex:
--------------------------------------------------------------------------------
 1 | <div class="max-w-sm mx-auto">
 2 |   <span class="flex justify-between">
 3 |     <div class="text-5xl font-light">Feeds</div>
 4 |     <a href="<%= rss_path(@conn, :new) %>" class="self-center bg-white hover:bg-green border border-green text-lg text-green hover:text-white px-6 py-2 rounded-full">New</a>
 5 |   </span>
 6 |   <hr class="w-full h-px bg-green-lightest mb-8">
 7 | </div>
 8 | 
 9 | <div class="max-w-sm mx-auto">
10 |   <%= for feed <- @feeds do %>
11 |     <div class="mb-4">
12 |       <div class="flex justify-between items-center">
13 |         <div id="feedName" class="text-3xl py-2"><%= feed.name %></div>
14 | 
15 |         <div class="relative inline-block">
16 |           <button id="btn-<%= feed.id %>" onclick="PlanetEx.openFeedMenu(event, '<%= feed.id %>')" class="cursor-pointer focus:outline-none dropdown-button">
17 |             <svg  class="inline-block h-6 w-6" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20"><path d="M10 12a2 2 0 1 1 0-4 2 2 0 0 1 0 4zm0-6a2 2 0 1 1 0-4 2 2 0 0 1 0 4zm0 12a2 2 0 1 1 0-4 2 2 0 0 1 0 4z"/></svg>
18 |           </button>
19 |           <div id="<%= feed.id %>-dropdown" class="hidden absolute bg-grey-lightest shadow z-10 dropdown-content">
20 |             <%= link("Edit", to: rss_path(@conn, :edit, feed.id), class: "text-black py-4 px-6 block hover:bg-grey-lighter") %>
21 |             <%= link("Delete", to: rss_path(@conn, :delete, feed.id), class: "text-black py-4 px-6 block hover:bg-grey-lighter", method: :delete, data: [confirm: "Are you sure you want to delete this feed?"]) %>
22 |           </div>
23 |         </div>
24 |       </div>
25 |       <p class="py-1"><%= feed.author %></p>
26 |       <a class="py-1 text-green no-underline hover:underline" href="<%= feed.url %>" target="_blank"><%= feed.url %></a>
27 |     </div>
28 |   <% end %>
29 | </div>
30 | 
31 | <script> PlanetEx.setupCloseFeedMenuHandler(); </script>
32 | 


--------------------------------------------------------------------------------
/lib/planet_web/templates/rss/new.html.eex:
--------------------------------------------------------------------------------
1 | <div class="text-center mt-2 mb-12">
2 |   <span class="text-4xl md:text-5xl font-light">Add an <strong>RSS</strong> Feed</span>
3 | </div>
4 | 
5 | <%= render PlanetExWeb.RssView, "_form.html", Map.merge(assigns, %{action: rss_path(@conn, :create), button_text: "Add"}) %>
6 | 


--------------------------------------------------------------------------------
/lib/planet_web/views/entries_view.ex:
--------------------------------------------------------------------------------
1 | defmodule PlanetExWeb.EntriesView do
2 |   use PlanetExWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/planet_web/views/error_helpers.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.ErrorHelpers do
 2 |   @moduledoc """
 3 |   Conveniences for translating and building error messages.
 4 |   """
 5 | 
 6 |   use Phoenix.HTML
 7 | 
 8 |   @doc """
 9 |   Generates tag for inlined form input errors.
10 |   """
11 |   def error_tag(form, field) do
12 |     Enum.map(Keyword.get_values(form.errors, field), fn error ->
13 |       content_tag(:span, translate_error(error), class: "text-red")
14 |     end)
15 |   end
16 | 
17 |   @doc """
18 |   Translates an error message using gettext.
19 |   """
20 |   def translate_error({msg, opts}) do
21 |     # When using gettext, we typically pass the strings we want
22 |     # to translate as a static argument:
23 |     #
24 |     #     # Translate "is invalid" in the "errors" domain
25 |     #     dgettext "errors", "is invalid"
26 |     #
27 |     #     # Translate the number of files with plural rules
28 |     #     dngettext "errors", "1 file", "%{count} files", count
29 |     #
30 |     # Because the error messages we show in our forms and APIs
31 |     # are defined inside Ecto, we need to translate them dynamically.
32 |     # This requires us to call the Gettext module passing our gettext
33 |     # backend as first argument.
34 |     #
35 |     # Note we use the "errors" domain, which means translations
36 |     # should be written to the errors.po file. The :count option is
37 |     # set by Ecto and indicates we should also apply plural rules.
38 |     if count = opts[:count] do
39 |       Gettext.dngettext(PlanetExWeb.Gettext, "errors", msg, msg, count, opts)
40 |     else
41 |       Gettext.dgettext(PlanetExWeb.Gettext, "errors", msg, opts)
42 |     end
43 |   end
44 | end
45 | 


--------------------------------------------------------------------------------
/lib/planet_web/views/error_view.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.ErrorView do
 2 |   use PlanetExWeb, :view
 3 | 
 4 |   # If you want to customize a particular status code
 5 |   # for a certain format, you may uncomment below.
 6 |   # def render("500.html", _assigns) do
 7 |   #   "Internal Server Error"
 8 |   # end
 9 | 
10 |   # By default, Phoenix returns the status message from
11 |   # the template name. For example, "404.html" becomes
12 |   # "Not Found".
13 |   def template_not_found(template, _assigns) do
14 |     Phoenix.Controller.status_message_from_template(template)
15 |   end
16 | end
17 | 


--------------------------------------------------------------------------------
/lib/planet_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule PlanetExWeb.LayoutView do
2 |   use PlanetExWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/planet_web/views/page_view.ex:
--------------------------------------------------------------------------------
1 | defmodule PlanetExWeb.PageView do
2 |   use PlanetExWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/planet_web/views/planet_view.ex:
--------------------------------------------------------------------------------
1 | defmodule PlanetExWeb.PlanetView do
2 |   use PlanetExWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/planet_web/views/rss_view.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.RssView do
 2 |   use PlanetExWeb, :view
 3 | 
 4 |   def last_updated_at(feed) do
 5 |     feed.entries
 6 |     |> List.first()
 7 |     |> no_nil()
 8 |     |> Map.get(:published, Timex.now())
 9 |     |> Timex.format!("{M}/{D}/{YYYY}")
10 |   end
11 | 
12 |   def published(datetime), do: Timex.format!(datetime, "{ISO:Extended}")
13 | 
14 |   def escape(text) do
15 |     text
16 |     |> html_escape
17 |     |> safe_to_string
18 |   end
19 | 
20 |   defp no_nil(feed), do: if(is_nil(feed), do: %{}, else: feed)
21 | end
22 | 


--------------------------------------------------------------------------------
/mix.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Mixfile do
 2 |   use Mix.Project
 3 | 
 4 |   def project do
 5 |     [
 6 |       app: :planetex,
 7 |       version: "0.0.2",
 8 |       elixir: "~> 1.4",
 9 |       elixirc_paths: elixirc_paths(Mix.env()),
10 |       compilers: [:phoenix, :gettext] ++ Mix.compilers(),
11 |       start_permanent: Mix.env() == :prod,
12 |       aliases: aliases(),
13 |       preferred_cli_env: [
14 |         "test.all": :test,
15 |         "test.feature": :test,
16 |         verify: :test
17 |       ],
18 |       deps: deps()
19 |     ]
20 |   end
21 | 
22 |   # Configuration for the OTP application.
23 |   #
24 |   # Type `mix help compile.app` for more information.
25 |   def application do
26 |     [
27 |       mod: {PlanetEx.Application, []},
28 |       extra_applications: [:logger, :runtime_tools]
29 |     ]
30 |   end
31 | 
32 |   # Specifies which paths to compile per environment.
33 |   defp elixirc_paths(:test), do: ["lib", "test/support"]
34 |   defp elixirc_paths(_), do: ["lib"]
35 | 
36 |   # Specifies your project dependencies.
37 |   #
38 |   # Type `mix help deps` for examples and options.
39 |   defp deps do
40 |     [
41 |       {:cowboy, "~> 1.0"},
42 |       {:credo, "~> 0.10.0", only: [:dev, :test], runtime: false},
43 |       {:distillery, "~> 2.0"},
44 |       {:dotenv, "~> 2.0.0", only: :dev},
45 |       {:gettext, "~> 0.11"},
46 |       {:httpoison, "~> 1.0", override: true},
47 |       {:mox, "~> 0.3.2", only: :test},
48 |       {:phoenix, "~> 1.3.2"},
49 |       {:phoenix_ecto, "~> 3.2"},
50 |       {:phoenix_html, "~> 2.10"},
51 |       {:phoenix_live_reload, "~> 1.0", only: :dev},
52 |       {:phoenix_pubsub, "~> 1.0"},
53 |       {:postgrex, ">= 0.0.0"},
54 |       {:sweet_xml, git: "git@github.com:mhanberg/sweet_xml.git"},
55 |       {:timex, "~> 3.0"},
56 |       {:wallaby, "~> 0.22.0"}
57 |     ]
58 |   end
59 | 
60 |   # Aliases are shortcuts or tasks specific to the current project.
61 |   # For example, to create, migrate and run the seeds file at once:
62 |   #
63 |   #     $ mix ecto.setup
64 |   #
65 |   # See the documentation for `Mix` for more info on aliases.
66 |   defp aliases do
67 |     [
68 |       "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
69 |       "ecto.reset": ["ecto.drop", "ecto.setup"],
70 |       test: [
71 |         "assets.compile --quiet",
72 |         "ecto.create --quiet",
73 |         "ecto.migrate",
74 |         "test"
75 |       ],
76 |       "test.feature": "test --only feature",
77 |       "test.all": "test --include feature",
78 |       "assets.compile": &compile_assets/1,
79 |       verify: [
80 |         "format --check-formatted",
81 |         "credo",
82 |         "test.all"
83 |       ]
84 |     ]
85 |   end
86 | 
87 |   defp compile_assets(_) do
88 |     Mix.shell().cmd("assets/node_modules/brunch/bin/brunch build assets/")
89 |   end
90 | end
91 | 


--------------------------------------------------------------------------------
/mix.lock:
--------------------------------------------------------------------------------
 1 | %{
 2 |   "artificery": {:hex, :artificery, "0.2.6", "f602909757263f7897130cbd006b0e40514a541b148d366ad65b89236b93497a", [:mix], [], "hexpm"},
 3 |   "bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], [], "hexpm"},
 4 |   "certifi": {:hex, :certifi, "2.5.1", "867ce347f7c7d78563450a18a6a28a8090331e77fa02380b4a21962a65d36ee5", [:rebar3], [{:parse_trans, "~>3.3", [hex: :parse_trans, repo: "hexpm", optional: false]}], "hexpm"},
 5 |   "combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm"},
 6 |   "connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm"},
 7 |   "cowboy": {:hex, :cowboy, "1.1.2", "61ac29ea970389a88eca5a65601460162d370a70018afe6f949a29dca91f3bb0", [:rebar3], [{:cowlib, "~> 1.0.2", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "~> 1.3.2", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm"},
 8 |   "cowlib": {:hex, :cowlib, "1.0.2", "9d769a1d062c9c3ac753096f868ca121e2730b9a377de23dec0f7e08b1df84ee", [:make], [], "hexpm"},
 9 |   "credo": {:hex, :credo, "0.10.0", "66234a95effaf9067edb19fc5d0cd5c6b461ad841baac42467afed96c78e5e9e", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm"},
10 |   "db_connection": {:hex, :db_connection, "1.1.3", "89b30ca1ef0a3b469b1c779579590688561d586694a3ce8792985d4d7e575a61", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, repo: "hexpm", optional: true]}], "hexpm"},
11 |   "decimal": {:hex, :decimal, "1.5.0", "b0433a36d0e2430e3d50291b1c65f53c37d56f83665b43d79963684865beab68", [:mix], [], "hexpm"},
12 |   "distillery": {:hex, :distillery, "2.0.9", "1e03e1bd97c0cd1187ce5882143fcc44812aa54d8c61b093801fab053bf07c98", [:mix], [{:artificery, "~> 0.2", [hex: :artificery, repo: "hexpm", optional: false]}], "hexpm"},
13 |   "dotenv": {:hex, :dotenv, "2.0.0", "87e77a94e54c20eca49989876395e26878b109f016f9fd9c42b65bb9c59bca3f", [:mix], [], "hexpm"},
14 |   "ecto": {:hex, :ecto, "2.2.10", "e7366dc82f48f8dd78fcbf3ab50985ceeb11cb3dc93435147c6e13f2cda0992e", [:mix], [{:db_connection, "~> 1.1", [hex: :db_connection, repo: "hexpm", optional: true]}, {:decimal, "~> 1.2", [hex: :decimal, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.8.0", [hex: :mariaex, repo: "hexpm", optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: true]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.13.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, repo: "hexpm", optional: true]}], "hexpm"},
15 |   "file_system": {:hex, :file_system, "0.2.6", "fd4dc3af89b9ab1dc8ccbcc214a0e60c41f34be251d9307920748a14bf41f1d3", [:mix], [], "hexpm"},
16 |   "gettext": {:hex, :gettext, "0.16.0", "4a7e90408cef5f1bf57c5a39e2db8c372a906031cc9b1466e963101cb927dafc", [:mix], [], "hexpm"},
17 |   "hackney": {:hex, :hackney, "1.15.1", "9f8f471c844b8ce395f7b6d8398139e26ddca9ebc171a8b91342ee15a19963f4", [:rebar3], [{:certifi, "2.5.1", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "6.0.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "1.0.1", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~>1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "1.1.4", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "hexpm"},
18 |   "httpoison": {:hex, :httpoison, "1.5.1", "0f55b5b673b03c5c327dac7015a67cb571b99b631acc0bc1b0b98dcd6b9f2104", [:mix], [{:hackney, "~> 1.8", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm"},
19 |   "idna": {:hex, :idna, "6.0.0", "689c46cbcdf3524c44d5f3dde8001f364cd7608a99556d8fbd8239a5798d4c10", [:rebar3], [{:unicode_util_compat, "0.4.1", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm"},
20 |   "jason": {:hex, :jason, "1.1.1", "d3ccb840dfb06f2f90a6d335b536dd074db748b3e7f5b11ab61d239506585eb2", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm"},
21 |   "metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm"},
22 |   "mime": {:hex, :mime, "1.3.0", "5e8d45a39e95c650900d03f897fbf99ae04f60ab1daa4a34c7a20a5151b7a5fe", [:mix], [], "hexpm"},
23 |   "mimerl": {:hex, :mimerl, "1.2.0", "67e2d3f571088d5cfd3e550c383094b47159f3eee8ffa08e64106cdf5e981be3", [:rebar3], [], "hexpm"},
24 |   "mox": {:hex, :mox, "0.3.2", "3b9b8364fd4f28628139de701d97c636b27a8f925f57a8d5a1b85fbd620dad3a", [:mix], [], "hexpm"},
25 |   "parse_trans": {:hex, :parse_trans, "3.3.0", "09765507a3c7590a784615cfd421d101aec25098d50b89d7aa1d66646bc571c1", [:rebar3], [], "hexpm"},
26 |   "phoenix": {:hex, :phoenix, "1.3.4", "aaa1b55e5523083a877bcbe9886d9ee180bf2c8754905323493c2ac325903dc5", [:mix], [{:cowboy, "~> 1.0", [hex: :cowboy, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.0", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.3.3 or ~> 1.4", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: false]}], "hexpm"},
27 |   "phoenix_ecto": {:hex, :phoenix_ecto, "3.4.0", "91cd39427006fe4b5588d69f0941b9c3d3d8f5e6477c563a08379de7de2b0c58", [:mix], [{:ecto, "~> 2.1", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.9", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
28 |   "phoenix_html": {:hex, :phoenix_html, "2.12.0", "1fb3c2e48b4b66d75564d8d63df6d53655469216d6b553e7e14ced2b46f97622", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
29 |   "phoenix_live_reload": {:hex, :phoenix_live_reload, "1.1.5", "8d4c9b1ef9ca82deee6deb5a038d6d8d7b34b9bb909d99784a49332e0d15b3dc", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.0 or ~> 1.2 or ~> 1.3", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm"},
30 |   "phoenix_pubsub": {:hex, :phoenix_pubsub, "1.1.0", "d55e25ff1ff8ea2f9964638366dfd6e361c52dedfd50019353598d11d4441d14", [:mix], [], "hexpm"},
31 |   "plug": {:hex, :plug, "1.6.2", "e06a7bd2bb6de5145da0dd950070110dce88045351224bd98e84edfdaaf5ffee", [:mix], [{:cowboy, "~> 1.0.1 or ~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}], "hexpm"},
32 |   "poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm"},
33 |   "poolboy": {:hex, :poolboy, "1.5.2", "392b007a1693a64540cead79830443abf5762f5d30cf50bc95cb2c1aaafa006b", [:rebar3], [], "hexpm"},
34 |   "postgrex": {:hex, :postgrex, "0.13.5", "3d931aba29363e1443da167a4b12f06dcd171103c424de15e5f3fc2ba3e6d9c5", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 1.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: false]}], "hexpm"},
35 |   "ranch": {:hex, :ranch, "1.3.2", "e4965a144dc9fbe70e5c077c65e73c57165416a901bd02ea899cfd95aa890986", [:rebar3], [], "hexpm"},
36 |   "ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.4", "f0eafff810d2041e93f915ef59899c923f4568f4585904d010387ed74988e77b", [:make, :mix, :rebar3], [], "hexpm"},
37 |   "sweet_xml": {:git, "git@github.com:mhanberg/sweet_xml.git", "cd217a514105f18d95b658045759e61bae6d3041", []},
38 |   "timex": {:hex, :timex, "3.3.0", "e0695aa0ddb37d460d93a2db34d332c2c95a40c27edf22fbfea22eb8910a9c8d", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:gettext, "~> 0.10", [hex: :gettext, repo: "hexpm", optional: false]}, {:tzdata, "~> 0.1.8 or ~> 0.5", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm"},
39 |   "tzdata": {:hex, :tzdata, "0.5.19", "7962a3997bf06303b7d1772988ede22260f3dae1bf897408ebdac2b4435f4e6a", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm"},
40 |   "unicode_util_compat": {:hex, :unicode_util_compat, "0.4.1", "d869e4c68901dd9531385bb0c8c40444ebf624e60b6962d95952775cac5e90cd", [:rebar3], [], "hexpm"},
41 |   "wallaby": {:hex, :wallaby, "0.22.0", "e5d16bfa7ab23562c8a6e3b0a31445a2fd470ca622082a910114807ba823780d", [:mix], [{:httpoison, "~> 0.12 or ~> 1.0", [hex: :httpoison, repo: "hexpm", optional: false]}, {:poison, ">= 1.4.0", [hex: :poison, repo: "hexpm", optional: false]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: false]}], "hexpm"},
42 | }
43 | 


--------------------------------------------------------------------------------
/priv/gettext/en/LC_MESSAGES/errors.po:
--------------------------------------------------------------------------------
 1 | ## `msgid`s in this file come from POT (.pot) files.
 2 | ##
 3 | ## Do not add, change, or remove `msgid`s manually here as
 4 | ## they're tied to the ones in the corresponding POT file
 5 | ## (with the same domain).
 6 | ##
 7 | ## Use `mix gettext.extract --merge` or `mix gettext.merge`
 8 | ## to merge POT files into PO files.
 9 | msgid ""
10 | msgstr ""
11 | "Language: en\n"
12 | 
13 | ## From Ecto.Changeset.cast/4
14 | msgid "can't be blank"
15 | msgstr ""
16 | 
17 | ## From Ecto.Changeset.unique_constraint/3
18 | msgid "has already been taken"
19 | msgstr ""
20 | 
21 | ## From Ecto.Changeset.put_change/3
22 | msgid "is invalid"
23 | msgstr ""
24 | 
25 | ## From Ecto.Changeset.validate_acceptance/3
26 | msgid "must be accepted"
27 | msgstr ""
28 | 
29 | ## From Ecto.Changeset.validate_format/3
30 | msgid "has invalid format"
31 | msgstr ""
32 | 
33 | ## From Ecto.Changeset.validate_subset/3
34 | msgid "has an invalid entry"
35 | msgstr ""
36 | 
37 | ## From Ecto.Changeset.validate_exclusion/3
38 | msgid "is reserved"
39 | msgstr ""
40 | 
41 | ## From Ecto.Changeset.validate_confirmation/3
42 | msgid "does not match confirmation"
43 | msgstr ""
44 | 
45 | ## From Ecto.Changeset.no_assoc_constraint/3
46 | msgid "is still associated with this entry"
47 | msgstr ""
48 | 
49 | msgid "are still associated with this entry"
50 | msgstr ""
51 | 
52 | ## From Ecto.Changeset.validate_length/3
53 | msgid "should be %{count} character(s)"
54 | msgid_plural "should be %{count} character(s)"
55 | msgstr[0] ""
56 | msgstr[1] ""
57 | 
58 | msgid "should have %{count} item(s)"
59 | msgid_plural "should have %{count} item(s)"
60 | msgstr[0] ""
61 | msgstr[1] ""
62 | 
63 | msgid "should be at least %{count} character(s)"
64 | msgid_plural "should be at least %{count} character(s)"
65 | msgstr[0] ""
66 | msgstr[1] ""
67 | 
68 | msgid "should have at least %{count} item(s)"
69 | msgid_plural "should have at least %{count} item(s)"
70 | msgstr[0] ""
71 | msgstr[1] ""
72 | 
73 | msgid "should be at most %{count} character(s)"
74 | msgid_plural "should be at most %{count} character(s)"
75 | msgstr[0] ""
76 | msgstr[1] ""
77 | 
78 | msgid "should have at most %{count} item(s)"
79 | msgid_plural "should have at most %{count} item(s)"
80 | msgstr[0] ""
81 | msgstr[1] ""
82 | 
83 | ## From Ecto.Changeset.validate_number/3
84 | msgid "must be less than %{number}"
85 | msgstr ""
86 | 
87 | msgid "must be greater than %{number}"
88 | msgstr ""
89 | 
90 | msgid "must be less than or equal to %{number}"
91 | msgstr ""
92 | 
93 | msgid "must be greater than or equal to %{number}"
94 | msgstr ""
95 | 
96 | msgid "must be equal to %{number}"
97 | msgstr ""
98 | 


--------------------------------------------------------------------------------
/priv/gettext/errors.pot:
--------------------------------------------------------------------------------
 1 | ## This file is a PO Template file.
 2 | ##
 3 | ## `msgid`s here are often extracted from source code.
 4 | ## Add new translations manually only if they're dynamic
 5 | ## translations that can't be statically extracted.
 6 | ##
 7 | ## Run `mix gettext.extract` to bring this file up to
 8 | ## date. Leave `msgstr`s empty as changing them here as no
 9 | ## effect: edit them in PO (`.po`) files instead.
10 | 
11 | ## From Ecto.Changeset.cast/4
12 | msgid "can't be blank"
13 | msgstr ""
14 | 
15 | ## From Ecto.Changeset.unique_constraint/3
16 | msgid "has already been taken"
17 | msgstr ""
18 | 
19 | ## From Ecto.Changeset.put_change/3
20 | msgid "is invalid"
21 | msgstr ""
22 | 
23 | ## From Ecto.Changeset.validate_acceptance/3
24 | msgid "must be accepted"
25 | msgstr ""
26 | 
27 | ## From Ecto.Changeset.validate_format/3
28 | msgid "has invalid format"
29 | msgstr ""
30 | 
31 | ## From Ecto.Changeset.validate_subset/3
32 | msgid "has an invalid entry"
33 | msgstr ""
34 | 
35 | ## From Ecto.Changeset.validate_exclusion/3
36 | msgid "is reserved"
37 | msgstr ""
38 | 
39 | ## From Ecto.Changeset.validate_confirmation/3
40 | msgid "does not match confirmation"
41 | msgstr ""
42 | 
43 | ## From Ecto.Changeset.no_assoc_constraint/3
44 | msgid "is still associated with this entry"
45 | msgstr ""
46 | 
47 | msgid "are still associated with this entry"
48 | msgstr ""
49 | 
50 | ## From Ecto.Changeset.validate_length/3
51 | msgid "should be %{count} character(s)"
52 | msgid_plural "should be %{count} character(s)"
53 | msgstr[0] ""
54 | msgstr[1] ""
55 | 
56 | msgid "should have %{count} item(s)"
57 | msgid_plural "should have %{count} item(s)"
58 | msgstr[0] ""
59 | msgstr[1] ""
60 | 
61 | msgid "should be at least %{count} character(s)"
62 | msgid_plural "should be at least %{count} character(s)"
63 | msgstr[0] ""
64 | msgstr[1] ""
65 | 
66 | msgid "should have at least %{count} item(s)"
67 | msgid_plural "should have at least %{count} item(s)"
68 | msgstr[0] ""
69 | msgstr[1] ""
70 | 
71 | msgid "should be at most %{count} character(s)"
72 | msgid_plural "should be at most %{count} character(s)"
73 | msgstr[0] ""
74 | msgstr[1] ""
75 | 
76 | msgid "should have at most %{count} item(s)"
77 | msgid_plural "should have at most %{count} item(s)"
78 | msgstr[0] ""
79 | msgstr[1] ""
80 | 
81 | ## From Ecto.Changeset.validate_number/3
82 | msgid "must be less than %{number}"
83 | msgstr ""
84 | 
85 | msgid "must be greater than %{number}"
86 | msgstr ""
87 | 
88 | msgid "must be less than or equal to %{number}"
89 | msgstr ""
90 | 
91 | msgid "must be greater than or equal to %{number}"
92 | msgstr ""
93 | 
94 | msgid "must be equal to %{number}"
95 | msgstr ""
96 | 


--------------------------------------------------------------------------------
/priv/repo/migrations/20180530015131_create_rss.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Repo.Migrations.CreateRss do
 2 |   use Ecto.Migration
 3 | 
 4 |   def change do
 5 |     create table(:rss) do
 6 |       add :name, :string
 7 |       add :url, :string
 8 |       add :author, :string
 9 | 
10 |       timestamps
11 |     end
12 | 
13 |     create unique_index(:rss, :url)
14 |     create index(:rss, :name)
15 |     create index(:rss, :author)
16 |   end
17 | end
18 | 


--------------------------------------------------------------------------------
/priv/repo/migrations/20180728183311_add_sharepoint_column_to_rss_table.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Repo.Migrations.AddSharepointColumnToRssTable do
 2 |   use Ecto.Migration
 3 | 
 4 |   def change do
 5 |     alter table("rss") do
 6 |       add :is_sharepoint, :boolean, default: false, null: false
 7 |     end
 8 |   end
 9 | end
10 | 


--------------------------------------------------------------------------------
/priv/repo/migrations/20180922023130_create_planets.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Repo.Migrations.CreatePlanets do
 2 |   use Ecto.Migration
 3 | 
 4 |   def up do
 5 |     create table(:planets) do
 6 |       add :title, :string
 7 |       add :url, :string
 8 |       add :author, :string
 9 | 
10 |       timestamps()
11 |     end
12 | 
13 |     flush()
14 | 
15 |     now = NaiveDateTime.utc_now()
16 | 
17 |     PlanetEx.Repo.insert_all(
18 |       "planets",
19 |       [
20 |         [
21 |           title: "Our Planet Feed",
22 |           url: "Our Planet URL",
23 |           author: "Our Planet Contributors",
24 |           inserted_at: now,
25 |           updated_at: now
26 |         ]
27 |       ]
28 |     )
29 |   end
30 | 
31 |   def down do
32 |     drop table(:planets)
33 |   end
34 | end
35 | 


--------------------------------------------------------------------------------
/priv/repo/seeds.exs:
--------------------------------------------------------------------------------
 1 | ~w(
 2 |   mitchellhanberg.com
 3 |   sep.com
 4 |   robots.thoughtbot.com
 5 |   spin.atomicobject.com
 6 |   engineering.github.com
 7 | )
 8 | |> Enum.with_index()
 9 | |> Enum.each(fn {url, index} ->
10 |   PlanetEx.Feeds.create_rss(%{
11 |     name: "name #{index}",
12 |     url: url,
13 |     author: "author: #{index}"
14 |   })
15 | end)
16 | 


--------------------------------------------------------------------------------
/rel/commands/migrate.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | 
3 | release_ctl eval --mfa "PlanetEx.ReleaseTasks.migrate/1" -- "$@"
4 | 


--------------------------------------------------------------------------------
/rel/config.exs:
--------------------------------------------------------------------------------
 1 | # Import all plugins from `rel/plugins`
 2 | # They can then be used by adding `plugin MyPlugin` to
 3 | # either an environment, or release definition, where
 4 | # `MyPlugin` is the name of the plugin module.
 5 | ~w(rel plugins *.exs)
 6 | |> Path.join()
 7 | |> Path.wildcard()
 8 | |> Enum.map(&Code.eval_file(&1))
 9 | 
10 | use Mix.Releases.Config,
11 |   # This sets the default release built by `mix release`
12 |   default_release: :default,
13 |   # This sets the default environment used by `mix release`
14 |   default_environment: Mix.env()
15 | 
16 | # For a full list of config options for both releases
17 | # and environments, visit https://hexdocs.pm/distillery/config/distillery.html
18 | 
19 | # You may define one or more environments in this file,
20 | # an environment's settings will override those of a release
21 | # when building in that environment, this combination of release
22 | # and environment configuration is called a profile
23 | 
24 | environment :dev do
25 |   # If you are running Phoenix, you should make sure that
26 |   # server: true is set and the code reloader is disabled,
27 |   # even in dev mode.
28 |   # It is recommended that you build with MIX_ENV=prod and pass
29 |   # the --env flag to Distillery explicitly if you want to use
30 |   # dev mode.
31 |   set(dev_mode: true)
32 |   set(include_erts: false)
33 |   set(cookie: :"mCg5ShK.CzaQ:t%f=;8;B`RPa@a7CI1c>T|:D54RV5w?}OnEY*$U6I=hgBJsd8xA")
34 | end
35 | 
36 | environment :prod do
37 |   set(include_erts: true)
38 |   set(include_src: false)
39 |   set(cookie: :"0:L)g|?f!Q|_]WHIA$|A.rrAYv3.4*`9eQ/:wT@H}}d)EX{q&G.B~IY$k{/c51Qa")
40 | end
41 | 
42 | # You may define one or more releases in this file.
43 | # If you have not set a default release, or selected one
44 | # when running `mix release`, the first release in the file
45 | # will be used by default
46 | 
47 | release :planetex do
48 |   set(version: current_version(:planetex))
49 | 
50 |   set(
51 |     applications: [
52 |       :runtime_tools
53 |     ]
54 |   )
55 | 
56 |   set(
57 |     commands: [
58 |       migrate: "rel/commands/migrate.sh"
59 |     ]
60 |   )
61 | end
62 | 


--------------------------------------------------------------------------------
/rel/plugins/.gitignore:
--------------------------------------------------------------------------------
1 | *.*
2 | !*.exs
3 | !.gitignore


--------------------------------------------------------------------------------
/test/planet/core/cron_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.CronTest do
 2 |   use ExUnit.Case
 3 | 
 4 |   alias PlanetEx.Core.Cron
 5 | 
 6 |   test "should execute the job" do
 7 |     id = self()
 8 |     job = fn -> send(id, :done) end
 9 | 
10 |     start_supervised!({Cron, job})
11 | 
12 |     assert_receive :done
13 |   end
14 | end
15 | 


--------------------------------------------------------------------------------
/test/planet/core/feed_parser/feed_parser_test.exs:
--------------------------------------------------------------------------------
  1 | defmodule PlanetEx.Core.FeedParserTest do
  2 |   use ExUnit.Case
  3 |   alias PlanetEx.Core.FeedParser
  4 |   import PlanetExWeb.Support
  5 | 
  6 |   test "returns and empty string when it is passed an Feed" do
  7 |     assert FeedParser.parse("") == %FeedParser.Feed{}
  8 |   end
  9 | 
 10 |   describe "parse/1 for atom feeds" do
 11 |     @atom_feed atom_fixture([author: "Mitchell Hanberg"], 5)
 12 | 
 13 |     test "turns an atom feed into a Feed struct" do
 14 |       actual = FeedParser.parse(@atom_feed)
 15 | 
 16 |       assert %FeedParser.Feed{} = actual
 17 |     end
 18 | 
 19 |     test "parses the title, url, and author fields" do
 20 |       expected = %FeedParser.Feed{
 21 |         title: "Blog's Blog",
 22 |         url: "https://www.blog.com/",
 23 |         author: "Mitchell Hanberg"
 24 |       }
 25 | 
 26 |       actual = FeedParser.parse(@atom_feed)
 27 | 
 28 |       assert expected.title == actual.title
 29 |       assert expected.url == actual.url
 30 |       assert expected.author == actual.author
 31 |     end
 32 | 
 33 |     test "parses all entries" do
 34 |       actual = FeedParser.parse(@atom_feed)
 35 | 
 36 |       assert 5 == Enum.count(actual.entries)
 37 |       assert %FeedParser.Entry{} = List.first(actual.entries)
 38 |     end
 39 | 
 40 |     test "parses entry data from feed" do
 41 |       expected_entry = %FeedParser.Entry{
 42 |         title: "Blog title",
 43 |         url: "https://www.blog.com/path/to/blog/",
 44 |         author: "Mitchell Hanberg",
 45 |         content: "<blockquote>",
 46 |         published: Timex.parse!("2018-02-22T12:00:00+00:00", "{ISO:Extended}")
 47 |       }
 48 | 
 49 |       actual =
 50 |         @atom_feed
 51 |         |> FeedParser.parse()
 52 |         |> Map.get(:entries)
 53 |         |> List.first()
 54 | 
 55 |       assert expected_entry.title == actual.title
 56 |       assert expected_entry.url == actual.url
 57 |       assert expected_entry.author == actual.author
 58 |       assert actual.content =~ expected_entry.content
 59 |       assert expected_entry.published == actual.published
 60 |     end
 61 | 
 62 |     test "replaces empty entry author field with one from feed author field" do
 63 |       xml_feed = atom_fixture(author: "Mitchell Hanberg", entry: nil)
 64 | 
 65 |       expected_entry = %FeedParser.Entry{
 66 |         title: "Integrate and Deploy React with Phoenix",
 67 |         url:
 68 |           "https://www.mitchellhanberg.com/post/2018/02/22/integrate-and-deploy-react-with-phoenix",
 69 |         author: "Mitchell Hanberg",
 70 |         content: "<blockquote>",
 71 |         published: Timex.parse!("2018-02-22T12:00:00+00:00", "{ISO:Extended}")
 72 |       }
 73 | 
 74 |       actual =
 75 |         xml_feed
 76 |         |> FeedParser.parse()
 77 |         |> Map.get(:entries)
 78 |         |> List.first()
 79 | 
 80 |       assert expected_entry.author == actual.author
 81 |     end
 82 | 
 83 |     test "replaces relative links in href values with absolute ones" do
 84 |       expected_entry = %FeedParser.Entry{
 85 |         title: "Integrate and Deploy React with Phoenix",
 86 |         url:
 87 |           "https://www.mitchellhanberg.com/post/2018/02/22/integrate-and-deploy-react-with-phoenix",
 88 |         author: "Mitchell Hanberg",
 89 |         content: ~s{<a href="https://www.blog.com/relativelink">},
 90 |         published: Timex.parse!("2018-02-22T12:00:00+00:00", "{ISO:Extended}")
 91 |       }
 92 | 
 93 |       actual =
 94 |         @atom_feed
 95 |         |> FeedParser.parse()
 96 |         |> Map.get(:entries)
 97 |         |> List.first()
 98 | 
 99 |       assert actual.content =~ expected_entry.content
100 |     end
101 | 
102 |     test "replaces relative img srcs with absolute ones" do
103 |       expected_entry = %FeedParser.Entry{
104 |         title: "Integrate and Deploy React with Phoenix",
105 |         url:
106 |           "https://www.mitchellhanberg.com/post/2018/02/22/integrate-and-deploy-react-with-phoenix",
107 |         author: "Mitchell Hanberg",
108 |         content: "<img src=\"https://www.blog.com/images/contact.png\"",
109 |         published: Timex.parse!("2018-02-22T12:00:00+00:00", "{ISO:Extended}")
110 |       }
111 | 
112 |       actual =
113 |         @atom_feed
114 |         |> FeedParser.parse()
115 |         |> Map.get(:entries)
116 |         |> List.first()
117 | 
118 |       assert actual.content =~ expected_entry.content
119 |     end
120 |   end
121 | 
122 |   describe "parse/1 for rss feeds" do
123 |     @rss_feed rss_fixture(5)
124 | 
125 |     test "turns an rss feed into a Feed struct" do
126 |       actual = FeedParser.parse(@rss_feed)
127 | 
128 |       assert %FeedParser.Feed{} = actual
129 |     end
130 | 
131 |     test "parses the title and url fields" do
132 |       expected = %FeedParser.Feed{
133 |         title: "SEP Blog",
134 |         url: "https://www.sep.com/sep-blog"
135 |       }
136 | 
137 |       actual = FeedParser.parse(@rss_feed)
138 | 
139 |       assert expected.title == actual.title
140 |       assert expected.url == actual.url
141 |     end
142 | 
143 |     test "parses all entries" do
144 |       actual = FeedParser.parse(@rss_feed)
145 | 
146 |       assert 5 == Enum.count(actual.entries)
147 |       assert %FeedParser.Entry{} = List.first(actual.entries)
148 |     end
149 | 
150 |     test "parses entry data from feed" do
151 |       expected_entry = %FeedParser.Entry{
152 |         title: "Blog title",
153 |         url: "https://www.sep.com/sep-blog/path/to/blog/",
154 |         content: "This is the content of this blog post",
155 |         author: "SEPeer",
156 |         published:
157 |           Timex.parse!(
158 |             "Tue, 19 Jun 2018 15:53:03 +0000",
159 |             "{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} {Z}"
160 |           )
161 |       }
162 | 
163 |       actual =
164 |         @rss_feed
165 |         |> FeedParser.parse()
166 |         |> Map.get(:entries)
167 |         |> List.first()
168 | 
169 |       assert expected_entry.title == actual.title
170 |       assert expected_entry.url == actual.url
171 |       assert actual.content =~ expected_entry.content
172 |       assert expected_entry.published == actual.published
173 |       assert expected_entry.author == actual.author
174 |     end
175 | 
176 |     test "parses entry data from feed with only description field" do
177 |       expected_entry = %FeedParser.Entry{
178 |         title: "Blog title",
179 |         url: "http://blog.com/path/to/post/",
180 |         content: "<p>This is the body of this blog post</p>",
181 |         author: nil,
182 |         published:
183 |           Timex.parse!(
184 |             "Fri, 30 Dec 2016 16:25:00 +0000",
185 |             "{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} {Z}"
186 |           )
187 |       }
188 | 
189 |       actual =
190 |         rss_fixture_only_description()
191 |         |> FeedParser.parse()
192 |         |> Map.get(:entries)
193 |         |> List.first()
194 | 
195 |       assert expected_entry.title == actual.title
196 |       assert expected_entry.url == actual.url
197 |       assert actual.content =~ expected_entry.content
198 |       assert expected_entry.published == actual.published
199 |       assert expected_entry.author == actual.author
200 |     end
201 |   end
202 | 
203 |   describe "parse/1 for sharepoint feeds" do
204 |     @sharepoint_feed sharepoint_fixture()
205 | 
206 |     test "turns an html doc into a Feed struct" do
207 |       actual = FeedParser.parse(@sharepoint_feed)
208 | 
209 |       assert %FeedParser.Feed{} = actual
210 |     end
211 | 
212 |     test "parses the title and url fields" do
213 |       expected = %FeedParser.Feed{
214 |         title: "Blog: Posts",
215 |         url: "https://sharepoint.sep.com:8383/personal/ohri/Blog/Lists/Posts/AllPosts.aspx"
216 |       }
217 | 
218 |       actual = FeedParser.parse(@sharepoint_feed)
219 | 
220 |       assert expected.title == actual.title
221 |     end
222 | 
223 |     test "parses all entries" do
224 |       actual = FeedParser.parse(@sharepoint_feed)
225 | 
226 |       assert 1 == Enum.count(actual.entries)
227 |       assert %FeedParser.Entry{} = List.first(actual.entries)
228 |     end
229 | 
230 |     test "parses entry data from feed" do
231 |       expected_entry = %FeedParser.Entry{
232 |         title: "Blog title",
233 |         url: "https://blog.com/post",
234 |         content: "This is the body of the blog post.",
235 |         author: "Blog Author",
236 |         published:
237 |           Timex.parse!(
238 |             "Tue, 03 Jul 2018 15:07:18 GMT",
239 |             "{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} {Zabbr}"
240 |           )
241 |       }
242 | 
243 |       actual =
244 |         @sharepoint_feed
245 |         |> FeedParser.parse()
246 |         |> Map.get(:entries)
247 |         |> List.first()
248 | 
249 |       assert expected_entry.title == actual.title
250 |       assert expected_entry.url == actual.url
251 |       assert actual.content =~ expected_entry.content
252 |       assert expected_entry.published == actual.published
253 |       assert expected_entry.author == actual.author
254 |     end
255 |   end
256 | end
257 | 


--------------------------------------------------------------------------------
/test/planet/core/feed_parser/feed_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.FeedParser.FeedTest do
 2 |   use ExUnit.Case
 3 |   alias PlanetEx.Core.FeedParser.{Entry, Feed}
 4 | 
 5 |   describe "merge/1" do
 6 |     test "takes a list of Feeds and returns a single Feed" do
 7 |       feeds = [
 8 |         %Feed{},
 9 |         %Feed{},
10 |         %Feed{}
11 |       ]
12 | 
13 |       actual = Feed.merge(feeds, %Feed{})
14 | 
15 |       assert %Feed{} = actual
16 |     end
17 | 
18 |     test "should merge Feed entries into a single Feed in descending order by published" do
19 |       expected_entries = [
20 |         %Entry{
21 |           title: "Entry1",
22 |           published: Timex.parse!("2018-06-24T04:50:34-05:00", "{ISO:Extended}")
23 |         },
24 |         %Entry{
25 |           title: "Entry2",
26 |           published: Timex.parse!("2017-06-24T04:50:34-05:00", "{ISO:Extended}")
27 |         },
28 |         %Entry{
29 |           title: "Entry3",
30 |           published: Timex.parse!("2015-06-24T04:50:34-05:00", "{ISO:Extended}")
31 |         },
32 |         %Entry{
33 |           title: "Entry4",
34 |           published: Timex.parse!("2013-06-24T04:50:34-05:00", "{ISO:Extended}")
35 |         }
36 |       ]
37 | 
38 |       feeds = [
39 |         %Feed{
40 |           entries: [
41 |             Enum.at(expected_entries, 0),
42 |             Enum.at(expected_entries, 2)
43 |           ]
44 |         },
45 |         %Feed{
46 |           entries: [
47 |             Enum.at(expected_entries, 1),
48 |             Enum.at(expected_entries, 3)
49 |           ]
50 |         }
51 |       ]
52 | 
53 |       actual =
54 |         feeds
55 |         |> Feed.merge(%Feed{})
56 |         |> Map.get(:entries)
57 | 
58 |       assert expected_entries == actual
59 |     end
60 |   end
61 | end
62 | 


--------------------------------------------------------------------------------
/test/planet/core/feed_server_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.FeedServerTest do
 2 |   use PlanetEx.DataCase
 3 |   alias PlanetEx.Core.{FeedParser, FeedServer}
 4 | 
 5 |   import PlanetExWeb.Support
 6 | 
 7 |   @stub_feed_xml atom_fixture([author: "Mitchell Hanberg"], 2)
 8 | 
 9 |   test "server initializes with feed" do
10 |     feed = feed_fixture(%{name: "Mitchell Hanberg's Blog", url: "feed_url"})
11 | 
12 |     FetchMock
13 |     |> Mox.expect(:get, fn ^feed -> @stub_feed_xml end)
14 | 
15 |     server = start_supervised!({FeedServer, [rss: feed]})
16 | 
17 |     assert %FeedParser.Feed{
18 |              entries: [
19 |                %FeedParser.Entry{},
20 |                %FeedParser.Entry{}
21 |              ]
22 |            } = FeedServer.status(server)
23 |   end
24 | 
25 |   test "server fetches feeds periodically" do
26 |     feed = feed_fixture(%{name: "Mitchell Hanberg's Blog", url: "feed_url"})
27 |     id = self()
28 | 
29 |     FetchMock
30 |     |> Mox.expect(:get, fn ^feed -> @stub_feed_xml end)
31 |     |> Mox.expect(:get, fn ^feed ->
32 |       send(id, :done)
33 |       @stub_feed_xml
34 |     end)
35 | 
36 |     start_supervised!({FeedServer, [rss: feed, timeout: 1]})
37 | 
38 |     assert_receive :done
39 |   end
40 | 
41 |   test "stops the server" do
42 |     feed = feed_fixture(%{name: "Mitchell Hanberg's Blog", url: "feed_url"})
43 | 
44 |     FetchMock
45 |     |> Mox.stub(:get, fn _ -> @stub_feed_xml end)
46 | 
47 |     feed_server = start_supervised!({FeedServer, [rss: feed]})
48 | 
49 |     FeedServer.stop(feed_server)
50 |     alive? = Process.alive?(feed_server)
51 | 
52 |     refute alive?
53 |   end
54 | 
55 |   test "updates the server" do
56 |     stale_feed = feed_fixture()
57 |     expected_name = "new author name"
58 |     updated_feed = struct(stale_feed, author: expected_name)
59 | 
60 |     FetchMock
61 |     |> Mox.stub(:get, fn _ -> @stub_feed_xml end)
62 | 
63 |     feed_server = start_supervised!({FeedServer, [rss: stale_feed]})
64 | 
65 |     FeedServer.update(feed_server, updated_feed)
66 | 
67 |     assert feed_server
68 |            |> :sys.get_state()
69 |            |> Map.fetch!(:rss)
70 |            |> Map.fetch!(:author) == expected_name
71 |   end
72 | end
73 | 


--------------------------------------------------------------------------------
/test/planet/core/server_farm_supervisor_test.exs:
--------------------------------------------------------------------------------
  1 | defmodule PlanetEx.Core.ServerFarmSupervisorTest do
  2 |   use PlanetEx.DataCase
  3 |   alias PlanetEx.Core.FeedParser.{Entry, Feed}
  4 |   alias PlanetEx.Core.{FeedStore, ServerFarm, ServerFarmSupervisor}
  5 |   import PlanetExWeb.Support
  6 | 
  7 |   @stub_feed_xml atom_fixture([author: "Mitchell Hanberg"], 2)
  8 | 
  9 |   setup do
 10 |     Mox.stub(FetchMock, :get, fn _ -> @stub_feed_xml end)
 11 | 
 12 |     :ok
 13 |   end
 14 | 
 15 |   test "should start a feed server for each feed in the database" do
 16 |     feed_fixture(%{name: "Blog1", url: "feed_url1"})
 17 |     feed_fixture(%{name: "Blog2", url: "feed_url2"})
 18 |     feed_fixture(%{name: "Blog3", url: "feed_url3"})
 19 | 
 20 |     start_supervised!(ServerFarmSupervisor)
 21 | 
 22 |     assert 3 ==
 23 |              FeedStore
 24 |              |> :sys.get_state()
 25 |              |> Map.fetch!(:feed_servers)
 26 |              |> Map.keys()
 27 |              |> Enum.count()
 28 |   end
 29 | 
 30 |   test "retrieves the aggregated feed" do
 31 |     start_supervised!(ServerFarmSupervisor)
 32 | 
 33 |     assert %PlanetEx.Core.FeedParser.Feed{} = FeedStore.status()
 34 |   end
 35 | 
 36 |   test "can merge a feed" do
 37 |     start_supervised!(ServerFarmSupervisor)
 38 | 
 39 |     FeedStore.push([
 40 |       %Feed{
 41 |         title: "Blerg",
 42 |         url: "https://blergnation.com",
 43 |         author: "Blergman",
 44 |         entries: [
 45 |           %Entry{
 46 |             title: "Blerg title",
 47 |             url: "Blerg url",
 48 |             author: "Blerg author",
 49 |             content: "Blerg content",
 50 |             published: "Blerg date"
 51 |           }
 52 |         ]
 53 |       }
 54 |     ])
 55 | 
 56 |     %{feed: actual} = :sys.get_state(FeedStore)
 57 | 
 58 |     assert "Our Planet Feed" == actual.title
 59 |     assert "Our Planet URL" == actual.url
 60 |     assert "Our Planet Contributors" == actual.author
 61 | 
 62 |     assert "Blerg content" ==
 63 |              actual.entries
 64 |              |> List.first()
 65 |              |> Map.fetch!(:content)
 66 |   end
 67 | 
 68 |   test "stores a new feed" do
 69 |     start_supervised!(ServerFarmSupervisor)
 70 | 
 71 |     new_feed = feed_fixture(%{name: "Blog1", url: "feed_url1"})
 72 |     new_feed_id = new_feed.id
 73 | 
 74 |     FeedStore.store(new_feed)
 75 | 
 76 |     actual = :sys.get_state(FeedStore).feed_servers
 77 | 
 78 |     assert Map.has_key?(actual, new_feed_id)
 79 | 
 80 |     assert 1 == ServerFarm |> DynamicSupervisor.which_children() |> Enum.count()
 81 |   end
 82 | 
 83 |   test "stops an old feed" do
 84 |     old_feed = feed_fixture()
 85 | 
 86 |     start_supervised!(ServerFarmSupervisor)
 87 | 
 88 |     FeedStore.remove(old_feed)
 89 | 
 90 |     actual =
 91 |       FeedStore
 92 |       |> :sys.get_state()
 93 |       |> Map.get(:feed_servers)
 94 |       |> Map.keys()
 95 | 
 96 |     refute actual |> Enum.any?(fn id -> id == old_feed.id end)
 97 | 
 98 |     assert 0 == ServerFarm |> DynamicSupervisor.which_children() |> Enum.count()
 99 |   end
100 | end
101 | 


--------------------------------------------------------------------------------
/test/planet/core/server_farm_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.Core.ServerFarmTest do
 2 |   use ExUnit.Case
 3 |   import Mox
 4 |   import PlanetExWeb.Support
 5 | 
 6 |   alias PlanetEx.Core.ServerFarm
 7 | 
 8 |   setup :set_mox_global
 9 |   setup :verify_on_exit!
10 | 
11 |   setup do
12 |     start_supervised!(ServerFarm)
13 | 
14 |     :ok
15 |   end
16 | 
17 |   @stub_feed_xml atom_fixture([author: "Mitchell Hanberg"], 2)
18 | 
19 |   test "start a child" do
20 |     feed = %PlanetEx.Feeds.Rss{id: 1, url: "Feed_url"}
21 | 
22 |     FetchMock
23 |     |> Mox.expect(:get, fn ^feed -> @stub_feed_xml end)
24 | 
25 |     assert {:ok, _} = ServerFarm.plant(feed)
26 |   end
27 | 
28 |   test "stops a child" do
29 |     feed = %PlanetEx.Feeds.Rss{id: 1, url: "Feed_url"}
30 | 
31 |     FetchMock
32 |     |> Mox.expect(:get, fn ^feed -> @stub_feed_xml end)
33 | 
34 |     {:ok, child_pid} = ServerFarm.plant(feed)
35 | 
36 |     assert :ok == ServerFarm.reap(child_pid)
37 |   end
38 | end
39 | 


--------------------------------------------------------------------------------
/test/planet/feeds/feeds_test.exs:
--------------------------------------------------------------------------------
  1 | defmodule PlanetEx.FeedsTest do
  2 |   use PlanetEx.DataCase
  3 | 
  4 |   alias PlanetEx.Feeds
  5 | 
  6 |   describe "rss" do
  7 |     alias PlanetEx.Feeds.Rss
  8 | 
  9 |     @valid_attrs %{author: "some author", name: "some name", url: "some url", is_sharepoint: true}
 10 |     @update_attrs %{
 11 |       author: "some updated author",
 12 |       name: "some updated name",
 13 |       url: "some updated url",
 14 |       is_sharepoint: false
 15 |     }
 16 |     @invalid_attrs %{author: nil, name: nil, url: nil, is_sharepoint: true}
 17 | 
 18 |     def feed_fixture(attrs \\ %{}) do
 19 |       {:ok, rss} =
 20 |         attrs
 21 |         |> Enum.into(@valid_attrs)
 22 |         |> Feeds.create_rss()
 23 | 
 24 |       rss
 25 |     end
 26 | 
 27 |     test "list_rss/0 returns all rss" do
 28 |       rss = feed_fixture()
 29 |       assert Feeds.list_rss() == [rss]
 30 |     end
 31 | 
 32 |     test "get_rss!/1 returns the rss with given id" do
 33 |       rss = feed_fixture()
 34 |       assert Feeds.get_rss!(rss.id) == rss
 35 |     end
 36 | 
 37 |     test "create_rss/1 with valid data creates a rss" do
 38 |       assert {:ok, %Rss{} = rss} = Feeds.create_rss(@valid_attrs)
 39 |       assert rss.author == "some author"
 40 |       assert rss.name == "some name"
 41 |       assert rss.url == "some url"
 42 |     end
 43 | 
 44 |     test "create_rss/1 with valid data creates a rss that is a sharepoint blog" do
 45 |       assert {:ok, %Rss{} = rss} = Feeds.create_rss(@valid_attrs |> Map.put(:is_sharepoint, true))
 46 |       assert rss.author == "some author"
 47 |       assert rss.name == "some name"
 48 |       assert rss.url == "some url"
 49 |       assert rss.is_sharepoint == true
 50 |     end
 51 | 
 52 |     test "create_rss/1 with invalid data returns error changeset" do
 53 |       assert {:error, %Ecto.Changeset{}} = Feeds.create_rss(@invalid_attrs)
 54 |     end
 55 | 
 56 |     test "update_rss/2 with valid data updates the rss" do
 57 |       rss = feed_fixture()
 58 |       assert {:ok, rss} = Feeds.update_rss(rss, @update_attrs)
 59 |       assert %Rss{} = rss
 60 |       assert rss.author == "some updated author"
 61 |       assert rss.name == "some updated name"
 62 |       assert rss.url == "some updated url"
 63 |     end
 64 | 
 65 |     test "update_rss/2 with invalid data returns error changeset" do
 66 |       rss = feed_fixture()
 67 |       assert {:error, %Ecto.Changeset{}} = Feeds.update_rss(rss, @invalid_attrs)
 68 |       assert rss == Feeds.get_rss!(rss.id)
 69 |     end
 70 | 
 71 |     test "delete_rss/1 deletes the rss" do
 72 |       rss = feed_fixture()
 73 |       assert {:ok, %Rss{}} = Feeds.delete_rss(rss)
 74 |       assert_raise Ecto.NoResultsError, fn -> Feeds.get_rss!(rss.id) end
 75 |     end
 76 | 
 77 |     test "change_rss/1 returns a rss changeset" do
 78 |       rss = feed_fixture()
 79 |       assert %Ecto.Changeset{} = Feeds.change_rss(rss)
 80 |     end
 81 |   end
 82 | 
 83 |   describe "planet" do
 84 |     alias PlanetEx.Feeds
 85 | 
 86 |     @valid_attrs %{author: "some author", title: "some title", url: "some url"}
 87 |     @update_attrs %{
 88 |       author: "some updated author",
 89 |       title: "some updated title",
 90 |       url: "some updated url"
 91 |     }
 92 |     @invalid_attrs %{author: nil, title: nil, url: nil}
 93 | 
 94 |     def planet_fixture(attrs \\ %{}) do
 95 |       {:ok, planet} =
 96 |         %Feeds.Planet{}
 97 |         |> Feeds.Planet.changeset(
 98 |           attrs
 99 |           |> Enum.into(@valid_attrs)
100 |         )
101 |         |> Repo.insert()
102 | 
103 |       planet
104 |     end
105 | 
106 |     test "get_planet/1 returns the planet with given id" do
107 |       planet = planet_fixture()
108 |       assert Feeds.get_planet!(planet.id) == planet
109 |     end
110 | 
111 |     test "update_planet/2 with valid data updates the planet" do
112 |       planet = planet_fixture()
113 |       assert {:ok, planet} = Feeds.update_planet(planet, @update_attrs)
114 |       assert %Feeds.Planet{} = planet
115 |       assert planet.author == "some updated author"
116 |       assert planet.title == "some updated title"
117 |       assert planet.url == "some updated url"
118 |     end
119 | 
120 |     test "update_planet/2 with invalid data returns error changeset" do
121 |       planet = planet_fixture()
122 |       assert {:error, %Ecto.Changeset{}} = Feeds.update_planet(planet, @invalid_attrs)
123 |       assert planet == Feeds.get_planet!(planet.id)
124 |     end
125 | 
126 |     test "change_planet/1 returns a planet changeset" do
127 |       planet = planet_fixture()
128 |       assert %Ecto.Changeset{} = Feeds.change_planet(planet)
129 |     end
130 |   end
131 | end
132 | 


--------------------------------------------------------------------------------
/test/planet_web/controllers/planet_controller_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.PlanetControllerTest do
 2 |   use PlanetExWeb.ConnCase
 3 | 
 4 |   alias PlanetEx.Feeds
 5 | 
 6 |   @create_attrs %{author: "some author", title: "some title", url: "some url"}
 7 |   @update_attrs %{
 8 |     author: "some updated author",
 9 |     title: "some updated title",
10 |     url: "some updated url"
11 |   }
12 |   @invalid_attrs %{author: nil, title: nil, url: nil}
13 | 
14 |   def fixture(:planet) do
15 |     {:ok, planet} =
16 |       %Feeds.Planet{}
17 |       |> Feeds.Planet.changeset(@create_attrs)
18 |       |> Repo.insert()
19 | 
20 |     planet
21 |   end
22 | 
23 |   describe "edit planet" do
24 |     setup [:create_planet]
25 | 
26 |     test "renders form for editing chosen planet", %{conn: conn, planet: planet} do
27 |       conn = get conn, planet_path(conn, :edit, planet)
28 |       assert html_response(conn, 200) =~ "Our Planet"
29 |     end
30 |   end
31 | 
32 |   describe "update planet" do
33 |     setup [:create_planet]
34 | 
35 |     test "redirects when data is valid", %{conn: conn, planet: planet} do
36 |       start_supervised!(PlanetEx.Core.ServerFarmSupervisor)
37 | 
38 |       conn = put(conn, planet_path(conn, :update, planet), planet: @update_attrs)
39 |       assert redirected_to(conn) == entries_path(conn, :index)
40 | 
41 |       :sys.get_state(PlanetEx.Core.ServerFarmSupervisor)
42 | 
43 |       conn = get conn, entries_path(conn, :index)
44 |       assert html_response(conn, 200) =~ "some updated title"
45 |     end
46 | 
47 |     test "renders errors when data is invalid", %{conn: conn, planet: planet} do
48 |       conn = put(conn, planet_path(conn, :update, planet), planet: @invalid_attrs)
49 |       assert html_response(conn, 200) =~ "Our Planet"
50 |     end
51 |   end
52 | 
53 |   defp create_planet(_) do
54 |     planet = fixture(:planet)
55 |     {:ok, planet: planet}
56 |   end
57 | end
58 | 


--------------------------------------------------------------------------------
/test/planet_web/controllers/rss_controller_test.exs:
--------------------------------------------------------------------------------
  1 | defmodule PlanetExWeb.RssControllerTest do
  2 |   use PlanetExWeb.ConnCase
  3 |   import PlanetExWeb.Support
  4 |   alias PlanetEx.Core.ServerFarmSupervisor
  5 | 
  6 |   @stub_feed_xml atom_fixture([author: "Mitchell Hanberg"], 2)
  7 | 
  8 |   setup do
  9 |     Mox.stub(FetchMock, :get, fn _ -> @stub_feed_xml end)
 10 | 
 11 |     :ok
 12 |   end
 13 | 
 14 |   describe "index/2" do
 15 |     setup do
 16 |       start_supervised!(PlanetEx.Core.ServerFarmSupervisor)
 17 | 
 18 |       :ok
 19 |     end
 20 | 
 21 |     test "should render all rss feeds", %{conn: conn} do
 22 |       feeds = [
 23 |         feed_fixture(%{url: "url1"}),
 24 |         feed_fixture(%{url: "url2"}),
 25 |         feed_fixture(%{url: "url3"})
 26 |       ]
 27 | 
 28 |       conn = get conn, "/rss"
 29 | 
 30 |       assert html_response(conn, 200) =~ "Feeds"
 31 | 
 32 |       for feed <- feeds do
 33 |         assert html_response(conn, 200) =~ feed.url
 34 |       end
 35 |     end
 36 |   end
 37 | 
 38 |   describe "create/2" do
 39 |     @valid_attrs %{
 40 |       rss: %{
 41 |         name: "Mitchell Hanberg's Blog",
 42 |         url: "mitchblog.com",
 43 |         author: "Mitchell Hanberg",
 44 |         is_sharepoint: false
 45 |       }
 46 |     }
 47 | 
 48 |     setup %{conn: conn} do
 49 |       start_supervised!(PlanetEx.Core.ServerFarmSupervisor)
 50 |       conn = post conn, "/rss", @valid_attrs
 51 | 
 52 |       {:ok, conn: conn}
 53 |     end
 54 | 
 55 |     test "should create an rss feed", %{conn: conn} do
 56 |       assert Repo.get_by!(PlanetEx.Feeds.Rss, url: "mitchblog.com")
 57 |       assert get_flash(conn, :success)
 58 |     end
 59 | 
 60 |     test "should redirect to new template on success", %{conn: conn} do
 61 |       assert redirected_to(conn, 303) =~ "/rss/new"
 62 |     end
 63 | 
 64 |     test "should not be able to add a url twice", %{conn: conn} do
 65 |       conn = post conn, "/rss", @valid_attrs
 66 | 
 67 |       assert html_response(conn, 400)
 68 |     end
 69 | 
 70 |     test "should plant a feed in the server farm", %{conn: conn} do
 71 |       post conn, "/rss", @valid_attrs
 72 | 
 73 |       rss_id = PlanetEx.Feeds.Rss |> Repo.get_by!(url: "mitchblog.com") |> Map.fetch!(:id)
 74 | 
 75 |       assert PlanetEx.Core.FeedStore
 76 |              |> :sys.get_state()
 77 |              |> Map.fetch!(:feed_servers)
 78 |              |> Map.has_key?(rss_id)
 79 |     end
 80 |   end
 81 | 
 82 |   describe "new/2" do
 83 |     test "should render new template", %{conn: conn} do
 84 |       conn = get conn, "/rss/new"
 85 | 
 86 |       assert html_response(conn, 200) =~ "Add an <strong>RSS</strong> Feed"
 87 |     end
 88 |   end
 89 | 
 90 |   describe "edit/2" do
 91 |     test "should render edit template with current data", %{conn: conn} do
 92 |       feed = feed_fixture(%{url: "url"})
 93 | 
 94 |       conn = get conn, "/rss/#{feed.id}/edit"
 95 | 
 96 |       assert html_response(conn, 200) =~ feed.name
 97 |       assert html_response(conn, 200) =~ feed.url
 98 |       assert html_response(conn, 200) =~ feed.author
 99 |     end
100 |   end
101 | 
102 |   describe "update/2" do
103 |     test "should update a feed", %{conn: conn} do
104 |       feed = feed_fixture(%{url: "url"})
105 | 
106 |       updated_attrs = %{
107 |         rss: %{
108 |           name: "updated name",
109 |           url: feed.url,
110 |           author: feed.author
111 |         }
112 |       }
113 | 
114 |       conn = patch(conn, "/rss/#{feed.id}", updated_attrs)
115 | 
116 |       assert redirected_to(conn, 303) =~ "/rss"
117 |       assert get_flash(conn, :success)
118 |     end
119 | 
120 |     test "should not be able to update a feed with another feeds url", %{conn: conn} do
121 |       feed = feed_fixture(%{url: "url"})
122 |       another_feed = feed_fixture(%{url: "taken_url"})
123 | 
124 |       updated_attrs = %{
125 |         rss: %{
126 |           name: feed.name,
127 |           url: another_feed.url,
128 |           author: feed.author
129 |         }
130 |       }
131 | 
132 |       conn = patch(conn, "/rss/#{feed.id}", updated_attrs)
133 | 
134 |       assert html_response(conn, 400)
135 |     end
136 |   end
137 | 
138 |   describe "delete/2" do
139 |     test "should delete a feed", %{conn: conn} do
140 |       feed = feed_fixture(%{url: "url"})
141 | 
142 |       start_supervised!(ServerFarmSupervisor)
143 | 
144 |       conn = delete(conn, "/rss/#{feed.id}")
145 | 
146 |       assert redirected_to(conn, 303) =~ "/rss"
147 |       assert get_flash(conn, :success)
148 |     end
149 | 
150 |     test "should reap a feed in the server farm", %{conn: conn} do
151 |       rss = %{url: "url"} |> feed_fixture()
152 |       rss_id = rss |> Map.fetch!(:id)
153 | 
154 |       start_supervised!(ServerFarmSupervisor)
155 | 
156 |       assert PlanetEx.Core.FeedStore
157 |              |> :sys.get_state()
158 |              |> Map.fetch!(:feed_servers)
159 |              |> Map.has_key?(rss_id)
160 | 
161 |       delete conn, "/rss/#{rss_id}"
162 | 
163 |       refute PlanetEx.Core.FeedStore
164 |              |> :sys.get_state()
165 |              |> Map.fetch!(:feed_servers)
166 |              |> Map.has_key?(rss_id)
167 |     end
168 | 
169 |     test "should return a 400 when id doesn't match a feed", %{conn: conn} do
170 |       start_supervised!(ServerFarmSupervisor)
171 | 
172 |       conn = delete(conn, "/rss/#{123_123_123}")
173 | 
174 |       assert redirected_to(conn, 303) =~ "/rss"
175 |       assert get_flash(conn, :danger)
176 |     end
177 |   end
178 | end
179 | 


--------------------------------------------------------------------------------
/test/planet_web/features/entries_feature_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.Features.EntriesTest do
 2 |   use PlanetExWeb.FeatureCase
 3 | 
 4 |   @moduletag :feature
 5 |   alias PlanetEx.Core.ServerFarmSupervisor
 6 |   import PlanetExWeb.Support
 7 | 
 8 |   import Wallaby.Query
 9 | 
10 |   describe "entries page" do
11 |     setup do
12 |       feed_fixture(%{name: "aname", url: "https://aurl.com"})
13 |       stub_feed_xml = feature_fixture([author: "Mitchell Hanberg"], 15)
14 | 
15 |       FetchMock
16 |       |> Mox.stub(:get, fn _ -> stub_feed_xml end)
17 | 
18 |       start_supervised!(ServerFarmSupervisor)
19 | 
20 |       :ok
21 |     end
22 | 
23 |     test "should display blog posts on the home page", %{session: session} do
24 |       session
25 |       |> visit("/")
26 |       |> assert_text("Blog Post title")
27 |     end
28 | 
29 |     test "should paginate blog posts", %{session: session} do
30 |       article_count =
31 |         session
32 |         |> visit("/")
33 |         |> all(css("article"))
34 |         |> Enum.count()
35 | 
36 |       assert article_count == 10
37 |     end
38 | 
39 |     test "should display second page of blog posts", %{session: session} do
40 |       article_count =
41 |         session
42 |         |> visit("/")
43 |         |> refute_has(link("Prev"))
44 |         |> click(link("Next"))
45 |         |> refute_has(link("Next"))
46 |         |> all(css("article"))
47 |         |> Enum.count()
48 | 
49 |       assert article_count == 5
50 |     end
51 |   end
52 | end
53 | 


--------------------------------------------------------------------------------
/test/planet_web/features/planet_feature_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.Features.PlanetExTest do
 2 |   use PlanetExWeb.FeatureCase
 3 | 
 4 |   @moduletag :feature
 5 |   alias PlanetEx.Core.ServerFarmSupervisor
 6 |   import PlanetExWeb.Support
 7 | 
 8 |   import Wallaby.Query
 9 | 
10 |   describe "Our Planet page" do
11 |     setup do
12 |       FetchMock
13 |       |> Mox.stub(:get, fn _ -> feature_fixture(author: "Mitchell Hanberg") end)
14 | 
15 |       start_supervised!(ServerFarmSupervisor)
16 | 
17 |       :ok
18 |     end
19 | 
20 |     test "successfully updating Our Planet takes you to the homepage", %{session: session} do
21 |       session =
22 |         session
23 |         |> visit("/")
24 |         |> click(Query.link("Our Planet"))
25 |         |> fill_in(Query.text_field("Title"), with: "New Blog title")
26 |         |> fill_in(Query.text_field("URL"), with: "https://validurl.com")
27 |         |> click(Query.button("Update"))
28 | 
29 |       session
30 |       |> assert_text("Success!")
31 | 
32 |       session
33 |       |> assert_text("New Blog title")
34 |     end
35 |   end
36 | end
37 | 


--------------------------------------------------------------------------------
/test/planet_web/features/rss_feature_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.Features.RssTest do
 2 |   use PlanetExWeb.FeatureCase
 3 | 
 4 |   @moduletag :feature
 5 |   alias PlanetEx.Core.ServerFarmSupervisor
 6 |   import PlanetExWeb.Support
 7 | 
 8 |   import Wallaby.Query
 9 | 
10 |   describe "feeds page" do
11 |     setup do
12 |       feeds = [
13 |         feed_fixture(%{name: "zname", url: "https://zurl.com"}),
14 |         feed_fixture(%{name: "aname", url: "https://aurl.com"}),
15 |         feed_fixture(%{name: "mname", url: "https://murl.com"})
16 |       ]
17 | 
18 |       FetchMock
19 |       |> Mox.stub(:get, fn _ -> feature_fixture(author: "Mitchell Hanberg") end)
20 | 
21 |       start_supervised!(ServerFarmSupervisor)
22 | 
23 |       %{fixtures: feeds}
24 |     end
25 | 
26 |     test "feeds should be listed in descending order by name", %{
27 |       session: session,
28 |       fixtures: fixtures
29 |     } do
30 |       feeds =
31 |         session
32 |         |> visit("/")
33 |         |> click(Query.link("Feeds"))
34 |         |> find(css("#feedName", count: 3))
35 | 
36 |       feeds
37 |       |> List.first()
38 |       |> assert_text(Enum.at(fixtures, 1).name)
39 | 
40 |       feeds
41 |       |> List.last()
42 |       |> assert_text(Enum.at(fixtures, 0).name)
43 |     end
44 | 
45 |     test "should be able to add an RSS feed", %{session: session} do
46 |       session
47 |       |> visit("/")
48 |       |> click(Query.link("Feeds"))
49 |       |> click(Query.link("New"))
50 |       |> fill_in(Query.text_field("Name"), with: "Blog title")
51 |       |> fill_in(Query.text_field("URL"), with: "https://bloggington.blog")
52 |       |> fill_in(Query.text_field("Author"), with: "The Blog Man")
53 |       |> click(Query.button("Add"))
54 |       |> assert_text("Success!")
55 |     end
56 | 
57 |     test "should be able to add a sharepoint RSS feed", %{session: session} do
58 |       session
59 |       |> visit("/")
60 |       |> click(Query.link("Feeds"))
61 |       |> click(Query.link("New"))
62 |       |> fill_in(Query.text_field("Name"), with: "Blog title")
63 |       |> fill_in(Query.text_field("URL"), with: "https://bloggington.blog")
64 |       |> fill_in(Query.text_field("Author"), with: "The Blog Man")
65 |       |> click(Query.checkbox("Sharepoint?"))
66 |       |> click(Query.button("Add"))
67 |       |> assert_text("Success!")
68 |     end
69 | 
70 |     test "should be able to update an RSS feed", %{session: session, fixtures: fixtures} do
71 |       feed = List.first(fixtures)
72 | 
73 |       session
74 |       |> visit("/")
75 |       |> click(Query.link("Feeds"))
76 |       |> click(Query.button("btn-#{feed.id}"))
77 |       |> click(Query.link("Edit"))
78 |       |> fill_in(Query.text_field("Name"), with: "New amazing name")
79 |       |> click(Query.button("Update"))
80 |       |> assert_text("Success!")
81 |     end
82 | 
83 |     test "should be able to delete an RSS feed", %{session: session, fixtures: fixtures} do
84 |       feed = List.first(fixtures)
85 | 
86 |       session
87 |       |> visit("/")
88 |       |> click(Query.link("Feeds"))
89 |       |> click(Query.button("btn-#{feed.id}"))
90 |       |> accept_confirm(fn s ->
91 |         s |> click(Query.link("Delete"))
92 |       end)
93 | 
94 |       session
95 |       |> assert_text("Success!")
96 |     end
97 |   end
98 | end
99 | 


--------------------------------------------------------------------------------
/test/planet_web/views/error_view_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.ErrorViewTest do
 2 |   use PlanetExWeb.ConnCase, async: true
 3 | 
 4 |   # Bring render/3 and render_to_string/3 for testing custom views
 5 |   import Phoenix.View
 6 | 
 7 |   test "renders 404.html" do
 8 |     assert render_to_string(PlanetExWeb.ErrorView, "404.html", []) == "Not Found"
 9 |   end
10 | 
11 |   test "renders 500.html" do
12 |     assert render_to_string(PlanetExWeb.ErrorView, "500.html", []) == "Internal Server Error"
13 |   end
14 | end
15 | 


--------------------------------------------------------------------------------
/test/planet_web/views/layout_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule PlanetExWeb.LayoutViewTest do
2 |   use PlanetExWeb.ConnCase, async: true
3 | end
4 | 


--------------------------------------------------------------------------------
/test/planet_web/views/page_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule PlanetExWeb.PageViewTest do
2 |   use PlanetExWeb.ConnCase, async: true
3 | end
4 | 


--------------------------------------------------------------------------------
/test/support/channel_case.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.ChannelCase do
 2 |   @moduledoc """
 3 |   This module defines the test case to be used by
 4 |   channel tests.
 5 | 
 6 |   Such tests rely on `Phoenix.ChannelTest` and also
 7 |   import other functionality to make it easier
 8 |   to build common datastructures and query the data layer.
 9 | 
10 |   Finally, if the test case interacts with the database,
11 |   it cannot be async. For this reason, every test runs
12 |   inside a transaction which is reset at the beginning
13 |   of the test unless the test case is marked as async.
14 |   """
15 | 
16 |   use ExUnit.CaseTemplate
17 | 
18 |   using do
19 |     quote do
20 |       # Import conveniences for testing with channels
21 |       use Phoenix.ChannelTest
22 | 
23 |       # The default endpoint for testing
24 |       @endpoint PlanetExWeb.Endpoint
25 |     end
26 |   end
27 | 
28 |   setup tags do
29 |     :ok = Ecto.Adapters.SQL.Sandbox.checkout(PlanetEx.Repo)
30 | 
31 |     unless tags[:async] do
32 |       Ecto.Adapters.SQL.Sandbox.mode(PlanetEx.Repo, {:shared, self()})
33 |     end
34 | 
35 |     :ok
36 |   end
37 | end
38 | 


--------------------------------------------------------------------------------
/test/support/conn_case.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.ConnCase do
 2 |   @moduledoc """
 3 |   This module defines the test case to be used by
 4 |   tests that require setting up a connection.
 5 | 
 6 |   Such tests rely on `Phoenix.ConnTest` and also
 7 |   import other functionality to make it easier
 8 |   to build common datastructures and query the data layer.
 9 | 
10 |   Finally, if the test case interacts with the database,
11 |   it cannot be async. For this reason, every test runs
12 |   inside a transaction which is reset at the beginning
13 |   of the test unless the test case is marked as async.
14 |   """
15 | 
16 |   use ExUnit.CaseTemplate
17 | 
18 |   using do
19 |     quote do
20 |       # Import conveniences for testing with connections
21 |       use Phoenix.ConnTest
22 |       import PlanetExWeb.Router.Helpers
23 |       import Ecto.Query, warn: false
24 |       alias PlanetEx.Repo
25 |       import Mox
26 | 
27 |       # The default endpoint for testing
28 |       @endpoint PlanetExWeb.Endpoint
29 |     end
30 |   end
31 | 
32 |   setup tags do
33 |     :ok = Ecto.Adapters.SQL.Sandbox.checkout(PlanetEx.Repo)
34 | 
35 |     unless tags[:async] do
36 |       Ecto.Adapters.SQL.Sandbox.mode(PlanetEx.Repo, {:shared, self()})
37 |     end
38 | 
39 |     Mox.set_mox_global()
40 | 
41 |     {:ok, conn: Phoenix.ConnTest.build_conn()}
42 |   end
43 | end
44 | 


--------------------------------------------------------------------------------
/test/support/data_case.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetEx.DataCase do
 2 |   @moduledoc """
 3 |   This module defines the setup for tests requiring
 4 |   access to the application's data layer.
 5 | 
 6 |   You may define functions here to be used as helpers in
 7 |   your tests.
 8 | 
 9 |   Finally, if the test case interacts with the database,
10 |   it cannot be async. For this reason, every test runs
11 |   inside a transaction which is reset at the beginning
12 |   of the test unless the test case is marked as async.
13 |   """
14 | 
15 |   use ExUnit.CaseTemplate
16 | 
17 |   using do
18 |     quote do
19 |       alias PlanetEx.Repo
20 | 
21 |       import Ecto
22 |       import Ecto.Changeset
23 |       import Ecto.Query
24 |       import PlanetEx.DataCase
25 |       import Mox
26 |     end
27 |   end
28 | 
29 |   setup tags do
30 |     :ok = Ecto.Adapters.SQL.Sandbox.checkout(PlanetEx.Repo)
31 | 
32 |     unless tags[:async] do
33 |       Ecto.Adapters.SQL.Sandbox.mode(PlanetEx.Repo, {:shared, self()})
34 |     end
35 | 
36 |     Mox.set_mox_global()
37 | 
38 |     :ok
39 |   end
40 | 
41 |   @doc """
42 |   A helper that transform changeset errors to a map of messages.
43 | 
44 |       assert {:error, changeset} = Accounts.create_user(%{password: "short"})
45 |       assert "password is too short" in errors_on(changeset).password
46 |       assert %{password: ["password is too short"]} = errors_on(changeset)
47 | 
48 |   """
49 |   def errors_on(changeset) do
50 |     Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
51 |       Enum.reduce(opts, message, fn {key, value}, acc ->
52 |         String.replace(acc, "%{#{key}}", to_string(value))
53 |       end)
54 |     end)
55 |   end
56 | end
57 | 


--------------------------------------------------------------------------------
/test/support/feature_case.ex:
--------------------------------------------------------------------------------
 1 | defmodule PlanetExWeb.FeatureCase do
 2 |   @moduledoc """
 3 |   This module sets up Feature tests using Wallaby and Google Chrome. 
 4 |   """
 5 |   use ExUnit.CaseTemplate
 6 | 
 7 |   using do
 8 |     quote do
 9 |       use Wallaby.DSL
10 | 
11 |       alias PlanetEx.Repo
12 |       import Ecto
13 |       import Ecto.Changeset
14 |       import Ecto.Query
15 |       import Mox
16 | 
17 |       import PlanetExWeb.Router.Helpers
18 |     end
19 |   end
20 | 
21 |   setup tags do
22 |     :ok = Ecto.Adapters.SQL.Sandbox.checkout(PlanetEx.Repo)
23 | 
24 |     unless tags[:async] do
25 |       Ecto.Adapters.SQL.Sandbox.mode(PlanetEx.Repo, {:shared, self()})
26 |     end
27 | 
28 |     Mox.set_mox_global()
29 | 
30 |     metadata = Phoenix.Ecto.SQL.Sandbox.metadata_for(PlanetEx.Repo, self())
31 |     {:ok, session} = Wallaby.start_session(metadata: metadata)
32 |     session = Wallaby.Browser.resize_window(session, 1024, 1024)
33 |     {:ok, session: session}
34 |   end
35 | end
36 | 


--------------------------------------------------------------------------------
/test/support/mocks/fetch_mock.ex:
--------------------------------------------------------------------------------
1 | Mox.defmock(FetchMock, for: PlanetEx.Core.FeedFetcher)
2 | 


--------------------------------------------------------------------------------
/test/support/support.ex:
--------------------------------------------------------------------------------
  1 | defmodule PlanetExWeb.Support do
  2 |   @moduledoc """
  3 |   This module contains test fixtures and other helpful support functions for use during test and development.
  4 |   """
  5 |   @valid_attrs %{author: "some author", name: "some name", url: "some url", is_sharepoint: false}
  6 | 
  7 |   def feed_fixture(attrs \\ %{}) do
  8 |     {:ok, rss} =
  9 |       attrs
 10 |       |> Enum.into(@valid_attrs)
 11 |       |> PlanetEx.Feeds.create_rss()
 12 | 
 13 |     rss
 14 |   end
 15 | 
 16 |   def atom_fixture(authors, count \\ 1) do
 17 |     author = Keyword.get(authors, :author, "Mitchell Hanberg")
 18 |     entry_author = Keyword.get(authors, :entry, author)
 19 | 
 20 |     beginning = """
 21 |     <?xml version="1.0" encoding="utf-8"?>
 22 |       <feed xmlns="http://www.w3.org/2005/Atom" >
 23 |       <generator uri="https://jekyllrb.com/" version="3.7.3">Jekyll</generator>
 24 |       <link href="https://www.blog.com/feed.xml" rel="self" type="application/atom+xml" />
 25 |       <link href="https://www.blog.com/" rel="alternate" type="text/html" />
 26 |       <updated>2018-06-03T22:29:43+00:00</updated>
 27 |       <id>unique_id1234</id>
 28 |       <title type="html">Blog's Blog</title>
 29 |       <author>
 30 |         <name>#{author}</name>
 31 |       </author>
 32 |     """
 33 | 
 34 |     relative_link = "&lt;a href=&quot;/relativelink&quot;&gt;create-react-app&lt;/a&gt;"
 35 |     relative_img = "&lt;img src=&quot;/images/contact.png&quot; alt=&quot;&quot; /&gt;"
 36 | 
 37 |     entry = """
 38 |     <entry><title type="html">Blog title</title><link href="https://www.blog.com/path/to/blog/" rel="alternate" type="text/html" title="Blog title" /><published>2018-02-22T12:00:00+00:00</published><updated>2018-02-22T12:00:00+00:00</updated><id>https://www.blog.com/path/to/blog</id><content type="html" xml:base="https://www.blog.com/path/to/blog/">&lt;blockquote&gt;
 39 |     &lt;p&gt;You’ve just finished your lightning fast Phoenix JSON API, what’s next?&lt;/p&gt;
 40 |     &lt;/blockquote&gt;
 41 | 
 42 |     &lt;h2 id=&quot;motivation&quot;&gt;Motivation&lt;/h2&gt;
 43 | 
 44 |     &lt;p&gt;#{relative_img}&lt;/p&gt;
 45 | 
 46 |     &lt;p&gt;My most recent side project, #{relative_link}, is a JSON REST API written with &lt;a href=&quot;https://elixir-lang.org/&quot;&gt;Elixir&lt;/a&gt; and &lt;a href=&quot;https://github.com/phoenixframework/phoenix&quot;&gt;Phoenix&lt;/a&gt;, designed to be the backend to an instant messaging application (e.g., Slack). There was a hackathon coming up at work, and I thought it’d be fun to make a frontend for Contact during it, and although Contact’s development was thoroughly test-driven, I wanted to make sure that my API was ready to be used.&lt;/p&gt;
 47 |     </content>
 48 |     <author>
 49 |     <name>#{entry_author}</name>
 50 |     </author>
 51 |     </entry>
 52 |     """
 53 | 
 54 |     ehnd = ~s(</feed>)
 55 | 
 56 |     beginning <> String.duplicate(entry, count) <> ehnd
 57 |   end
 58 | 
 59 |   def feature_fixture(authors, count \\ 1) do
 60 |     author = Keyword.get(authors, :author, "Mitchell Hanberg")
 61 |     entry_author = Keyword.get(authors, :entry, author)
 62 | 
 63 |     beginning = """
 64 |     <?xml version="1.0" encoding="utf-8"?>
 65 |     <feed xmlns="http://www.w3.org/2005/Atom" >
 66 |     <generator uri="https://jekyllrb.com/" version="3.7.3">Jekyll</generator>
 67 |     <link href="https://www.blog.com/feed.xml" rel="self" type="application/atom+xml" />
 68 |     <link href="https://www.blog.com/" rel="alternate" type="text/html" />
 69 |     <updated>2018-06-03T22:29:43+00:00</updated>
 70 |     <id>https://www.blog.com/</id>
 71 |     <title type="html">Blogs Blog</title>
 72 |     <author><name>#{author}</name></author>
 73 |     """
 74 | 
 75 |     entry = """
 76 |     <entry><title type="html">Blog Post title</title><link href="https://www.blog.com/path/to/post/" rel="alternate" type="text/html" title="Blog Post title" /><published>2018-02-22T12:00:00+00:00</published><updated>2018-02-22T12:00:00+00:00</updated><id>https://www.blog.com/path/to/post/</id><content type="html" xml:base="https://www.blog.com/path/to/post/">
 77 | 
 78 |     &lt;p&gt;This is a blog post!&lt;/p&gt;
 79 | 
 80 |     </content>
 81 |     <author>
 82 |     <name>#{entry_author}</name>
 83 |     </author>
 84 |     </entry>
 85 |     """
 86 | 
 87 |     ehnd = ~s(</feed>)
 88 | 
 89 |     beginning <> String.duplicate(entry, count) <> ehnd
 90 |   end
 91 | 
 92 |   def rss_fixture(count \\ 1) do
 93 |     beginning = """
 94 |     <?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
 95 |     xmlns:content="http://purl.org/rss/1.0/modules/content/"
 96 |     xmlns:wfw="http://wellformedweb.org/CommentAPI/"
 97 |     xmlns:dc="http://purl.org/dc/elements/1.1/"
 98 |     xmlns:atom="http://www.w3.org/2005/Atom"
 99 |     xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
100 |     xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
101 |     >
102 | 
103 |     <channel>
104 |     <title>SEP Blog</title>
105 |     <atom:link href="https://www.sep.com/sep-blog/feed/" rel="self" type="application/rss+xml" />
106 |     <link>https://www.sep.com/sep-blog</link>
107 |     <description>Featured Posts From SEPeers</description>
108 |     <lastBuildDate>Fri, 29 Jun 2018 19:18:53 +0000</lastBuildDate>
109 |     <language>en-US</language>
110 |     <sy:updatePeriod>hourly</sy:updatePeriod>
111 |     <sy:updateFrequency>1</sy:updateFrequency>
112 |     """
113 | 
114 |     item = """
115 |     <item>
116 |     <title>Blog title</title>
117 |     <link>https://www.sep.com/sep-blog/path/to/blog/</link>
118 |     <pubDate>Tue, 19 Jun 2018 15:53:03 +0000</pubDate>
119 |     <dc:creator><![CDATA[SEPeer]]></dc:creator>
120 |     <category><![CDATA[Please change category to your name]]></category>
121 |     <category><![CDATA[SEPeers]]></category>
122 | 
123 |     <guid isPermaLink="false">http://www.sep.com/sep-blog/?p=xxx</guid>
124 |     <description><![CDATA[This is the description of an item in an RSS feed...]]></description>
125 |     <content:encoded><![CDATA[<h3><img class="wp-image-9576 alignleft" src="http://www.sep.com/sep-blog/path/to/image.png" alt="" width="153" height="177" /><p>This is the content of this blog post</p>]]></content:encoded>
126 |     </item>
127 |     """
128 | 
129 |     ehnd = "</channel></rss>"
130 | 
131 |     beginning <> String.duplicate(item, count) <> ehnd
132 |   end
133 | 
134 |   def rss_fixture_only_description(count \\ 1) do
135 |     beginning = """
136 |     <?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
137 |     xmlns:content="http://purl.org/rss/1.0/modules/content/"
138 |     xmlns:wfw="http://wellformedweb.org/CommentAPI/"
139 |     xmlns:dc="http://purl.org/dc/elements/1.1/"
140 |     xmlns:atom="http://www.w3.org/2005/Atom"
141 |     xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
142 |     xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
143 |     >
144 | 
145 |     <channel>
146 |     <title>SEP Blog</title>
147 |     <atom:link href="https://www.sep.com/sep-blog/feed/" rel="self" type="application/rss+xml" />
148 |     <link>https://www.sep.com/sep-blog</link>
149 |     <description>Featured Posts From SEPeers</description>
150 |     <lastBuildDate>Fri, 29 Jun 2018 19:18:53 +0000</lastBuildDate>
151 |     <language>en-US</language>
152 |     <sy:updatePeriod>hourly</sy:updatePeriod>
153 |     <sy:updateFrequency>1</sy:updateFrequency>
154 |     """
155 | 
156 |     item = """
157 |     <item>
158 |     <title>Blog title</title>
159 |     <link>http://blog.com/path/to/post/</link>
160 |     <pubDate>Published on Fri, 30 Dec 2016 16:25:00 +0000</pubDate>
161 |     <guid isPermaLink="false">ID 2016-12-30T16:25:00 on http://blog.com</guid>
162 |     <description>&lt;p&gt;This is the body of this blog post&lt;/p&gt;</description>
163 |     </item>
164 |     """
165 | 
166 |     ehnd = "</channel></rss>"
167 | 
168 |     beginning <> String.duplicate(item, count) <> ehnd
169 |   end
170 | 
171 |   def sharepoint_fixture do
172 |     """
173 |     <html xmlns="http://www.w3.org/1999/xhtml" xmlns:dc="http://purl.org/dc/elements/1.1/" id="HtmlRootTag" dir="ltr"><!--?xml version="1.0" encoding="UTF-8"?--><!--RSS generated by Microsoft SharePoint Foundation RSS Generator on 7/29/2018 11:24:18 AM --><!--?xml-stylesheet type="text/xsl" href="/personal/path/to/blog" version="1.0"?--><head></head><body><rss version="2.0">
174 |     <channel>
175 |     <title>Blog: Posts</title>
176 |     <link />https://blog.com/path/to/blog
177 |     <description>RSS feed for the Posts list.</description>
178 |     <lastbuilddate>Sun, 29 Jul 2018 15:24:18 GMT</lastbuilddate>
179 |     <generator>Microsoft SharePoint Foundation RSS Generator</generator>
180 |     <ttl>60</ttl>
181 |     <language>en-US</language>
182 |     <img />
183 |     <title>Blog: Posts</title>
184 |     <url>https://blog.com/path/to/image.png</url>
185 |     <link />https://blog.com/path/to/blog
186 | 
187 |     <item>
188 |     <title>Blog title</title>
189 |     <link />https://blog.com/post
190 |     <description><!--[CDATA[<div--><b>Body:</b> <div><p>This is the body of the blog post.</p></div>
191 |     <div><b>Published:</b> 7/3/2018 11:03 AM</div>
192 |     ]]&gt;</description>
193 |     <author>Blog Author</author>
194 |     <pubdate>Tue, 03 Jul 2018 15:07:18 GMT</pubdate>
195 |     <guid ispermalink="true">https://blog.com/post</guid>
196 |     </item>
197 |     </channel>
198 |     </rss></body></html>
199 |     """
200 |   end
201 | 
202 |   def pry(passthrough) do
203 |     require IEx
204 |     # credo:disable-for-next-line
205 |     IEx.pry()
206 | 
207 |     passthrough
208 |   end
209 | end
210 | 


--------------------------------------------------------------------------------
/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.configure(timeout: :infinity, exclude: [feature: true])
2 | ExUnit.start()
3 | 
4 | Ecto.Adapters.SQL.Sandbox.mode(PlanetEx.Repo, :manual)
5 | Application.put_env(:wallaby, :base_url, PlanetExWeb.Endpoint.url())
6 | 
7 | {:ok, _} = Application.ensure_all_started(:wallaby)
8 | 


--------------------------------------------------------------------------------