text:
Catalyst::Manual::Intro - Introduction to Catalyst
This is a brief introduction to Catalyst. It explains the most important features of how Catalyst works and shows how to get a simple application up and running quickly. For an introduction (without code) to Catalyst itself, and why you should be using it, see Catalyst::Manual::About. For a systematic step-by-step introduction to writing an application with Catalyst, see Catalyst::Manual::Tutorial.
Catalyst is an elegant web application framework, extremely flexible yet extremely simple. It's similar to Ruby on Rails, Spring (Java), and Maypole, upon which it was originally based. Its most important design philosophy is to provide easy access to all the tools you need to develop web applications, with few restrictions on how you need to use these tools. However, this does mean that it is always possible to do things in a different way. Other web frameworks are initially simpler to use, but achieve this by locking the programmer into a single set of tools. Catalyst's emphasis on flexibility means that you have to think more to use it. We view this as a feature. For example, this leads to Catalyst being better suited to system integration tasks than other web frameworks.
Catalyst follows the Model-View-Controller (MVC) design pattern, allowing you to easily separate concerns, like content, presentation, and flow control, into separate modules. This separation allows you to modify code that handles one concern without affecting code that handles the others. Catalyst promotes the re-use of existing Perl modules that already handle common web application concerns well.
Here's how the Model, View, and Controller map to those concerns, with examples of well-known Perl modules you may want to use for each.
Access and modify content (data). DBIx::Class, Class::DBI, Xapian, Net::LDAP...
Present content to the user. Template Toolkit, Mason, HTML::Template...
Control the whole request phase, check parameters, dispatch actions, flow control. This is the meat of where Catalyst works.
If you're unfamiliar with MVC and design patterns, you may want to check out the original book on the subject, Design Patterns, by Gamma, Helm, Johnson, and Vlissides, also known as the Gang of Four (GoF). Many, many web application frameworks are based on MVC, which is becoming a popular design paradigm for the world wide web.
Catalyst is much more flexible than many other frameworks. Rest assured you can use your favorite Perl modules with Catalyst.
Multiple Models, Views, and Controllers
To build a Catalyst application, you handle each type of concern inside special modules called "Components". Often this code will be very simple, just calling out to Perl modules like those listed above under "MVC". Catalyst handles these components in a very flexible way. Use as many Models, Views, and Controllers as you like, using as many different Perl modules as you like, all in the same application. Want to manipulate multiple databases, and retrieve some data via LDAP? No problem. Want to present data from the same Model using Template Toolkit and PDF::Template? Easy.
Reuseable Components
Not only does Catalyst promote the re-use of already existing Perl modules, it also allows you to re-use your Catalyst components in multiple Catalyst applications.
Unrestrained URL-to-Action Dispatching
Catalyst allows you to dispatch any URLs to any application "Actions", even through regular expressions! Unlike most other frameworks, it doesn't require mod_rewrite or class and method names in URLs.
With Catalyst you register your actions and address them directly. For example:
sub hello : Local { my ( $self, $context ) = @_; $context->response->body('Hello World!'); }
Now http://localhost:3000/hello prints "Hello World!".
Note that actions with the :Local attribute are equivalent to using a :Path('action_name') attribute, so our action could be equivalently:
sub hi : Path('hello') { my ( $self, $context ) = @_; $context->response->body('Hello World!'); }
Support for CGI, mod_perl, Apache::Request, FastCGI
Use Catalyst::Engine::Apache or Catalyst::Engine::CGI. Another interesting engine is Catalyst::Engine::HTTP::Prefork - available from CPAN separately - which will turn the built server into a fully fledged production ready server (although you'll probably want to run it behind a front end proxy if you end up using it).
PSGI Support
Starting with Catalyst version 5.9 Catalyst ships with PSGI integration for even more powerful and flexible testing and deployment options. See Catalyst::PSGI for details.
The best part is that Catalyst implements all this flexibility in a very simple way.
Building Block Interface
Components interoperate very smoothly. For example, Catalyst automatically makes a "Context" object available to every component. Via the context, you can access the request object, share data between components, and control the flow of your application. Building a Catalyst application feels a lot like snapping together toy building blocks, and everything just works.
Component Auto-Discovery
No need to use all of your components. Catalyst automatically finds and loads them.
Pre-Built Components for Popular Modules
See Catalyst::Model::DBIC::Schema for DBIx::Class, or Catalyst::View::TT for Template Toolkit.
Built-in Test Framework
Catalyst comes with a built-in, lightweight http server and test framework, making it easy to test applications from the web browser, and the command line.
Helper Scripts
Catalyst provides helper scripts to quickly generate running starter code for components and unit tests. Install Catalyst::Devel and see Catalyst::Helper.
Here's how to install Catalyst and get a simple application up and running, using the helper scripts described above.
Installation of Catalyst should be straightforward:
# perl -MCPAN -e 'install Catalyst::Runtime' # perl -MCPAN -e 'install Catalyst::Devel' # perl -MCPAN -e 'install Catalyst::View::TT'
$ catalyst.pl MyApp # output omitted $ cd MyApp $ script/myapp_create.pl controller Library::Login
There are currently two flavors of publicly available Amazon Machine Images (AMI) that include all the elements you'd need to begin developing in a fully functional Catalyst environment within minutes. See Catalyst::Manual::Installation for more details.
$ script/myapp_server.pl
Now visit these locations with your favorite browser or user agent to see Catalyst in action:
(NOTE: Although we create a controller here, we don't actually use it. Both of these URLs should take you to the welcome page.)
Let's see how Catalyst works, by taking a closer look at the components and other parts of a Catalyst application.
Catalyst has an uncommonly flexible component system. You can define as many "Models", "Views", and "Controllers" as you like. As discussed previously, the general idea is that the View is responsible for the output of data to the user (typically via a web browser, but a View can also generate PDFs or e-mails, for example); the Model is responsible for providing data (typically from a relational database); and the Controller is responsible for interacting with the user and deciding how user input determines what actions the application takes.
In the world of MVC, there are frequent discussions and disagreements about the nature of each element - whether certain types of logic belong in the Model or the Controller, etc. Catalyst's flexibility means that this decision is entirely up to you, the programmer; Catalyst doesn't enforce anything. See Catalyst::Manual::About for a general discussion of these issues.
Model, View and Controller components must inherit from Catalyst::Model, Catalyst::View and Catalyst::Controller, respectively. These, in turn, inherit from Catalyst::Component which provides a simple class structure and some common class methods like config and new (constructor).
package MyApp::Controller::Catalog; use Moose; use namespace::autoclean; BEGIN { extends 'Catalyst::Controller' } __PACKAGE__->config( foo => 'bar' ); 1;
You don't have to use or otherwise register Models, Views, and Controllers. Catalyst automatically discovers and instantiates them when you call setup in the main application. All you need to do is put them in directories named for each Component type. You can use a short alias for each one.
To show how to define views, we'll use an already-existing base class for the Template Toolkit, Catalyst::View::TT. All we need to do is inherit from this class:
package MyApp::View::TT; use strict; use base 'Catalyst::View::TT'; 1;
(You can also generate this automatically by using the helper script:
script/myapp_create.pl view TT TT
where the first TT tells the script that the name of the view should be TT, and the second that it should be a Template Toolkit view.)
This gives us a process() method and we can now just do $c->forward('MyApp::View::TT') to render our templates. The base class makes process() implicit, so we don't have to say $c->forward(qw/MyApp::View::TT process/).
$c->forward(qw/MyApp::View::TT process/)
sub hello : Global { my ( $self, $c ) = @_; $c->stash->{template} = 'hello.tt'; } sub end : Private { my ( $self, $c ) = @_; $c->forward( $c->view('TT') ); }
You normally render templates at the end of a request, so it's a perfect use for the global end action.
In practice, however, you would use a default end action as supplied by Catalyst::Action::RenderView.
Also, be sure to put the template under the directory specified in $c->config->{root}, or you'll end up looking at the debug screen.
Models are providers of data. This data could come from anywhere - a search engine index, a spreadsheet, the file system - but typically a Model represents a database table. The data source does not intrinsically have much to do with web applications or Catalyst - it could just as easily be used to write an offline report generator or a command-line tool.
To show how to define models, again we'll use an already-existing base class, this time for DBIx::Class: Catalyst::Model::DBIC::Schema. We'll also need DBIx::Class::Schema::Loader.
But first, we need a database.
-- myapp.sql CREATE TABLE foo ( id INTEGER PRIMARY KEY, data TEXT ); CREATE TABLE bar ( id INTEGER PRIMARY KEY, foo INTEGER REFERENCES foo, data TEXT ); INSERT INTO foo (data) VALUES ('TEST!'); % sqlite3 /tmp/myapp.db < myapp.sql
Now we can create a DBIC::Schema model for this database.
script/myapp_create.pl model MyModel DBIC::Schema MySchema create=static 'dbi:SQLite:/tmp/myapp.db'
DBIx::Class::Schema::Loader can automatically load table layouts and relationships, and convert them into a static schema definition MySchema, which you can edit later.
Use the stash to pass data to your templates.
We add the following to MyApp/Controller/Root.pm
sub view : Global { my ( $self, $c, $id ) = @_; $c->stash->{item} = $c->model('MyModel::Foo')->find($id); } 1; sub end : Private { my ( $self, $c ) = @_; $c->stash->{template} ||= 'index.tt'; $c->forward( $c->view('TT') ); }
We then create a new template file "root/index.tt" containing:
The Id's data is [% item.data %]
Models do not have to be part of your Catalyst application; you can always call an outside module that serves as your Model:
# in a Controller sub list : Local { my ( $self, $c ) = @_; $c->stash->{template} = 'list.tt'; use Some::Outside::Database::Module; my @records = Some::Outside::Database::Module->search({ artist => 'Led Zeppelin', }); $c->stash->{records} = \@records; }
But by using a Model that is part of your Catalyst application, you gain several things: you don't have to use each component, Catalyst will find and load it automatically at compile-time; you can forward to the module, which can only be done to Catalyst components. Only Catalyst components can be fetched with $c->model('SomeModel').
Happily, since many people have existing Model classes that they would like to use with Catalyst (or, conversely, they want to write Catalyst models that can be used outside of Catalyst, e.g. in a cron job), it's trivial to write a simple component in Catalyst that slurps in an outside Model:
package MyApp::Model::DB; use base qw/Catalyst::Model::DBIC::Schema/; __PACKAGE__->config( schema_class => 'Some::DBIC::Schema', connect_info => ['dbi:SQLite:foo.db', '', '', {AutoCommit=>1}] ); 1;
and that's it! Now Some::DBIC::Schema is part of your Cat app as MyApp::Model::DB.
Within Catalyst, the common approach to writing a model for your application is wrapping a generic model (e.g. DBIx::Class::Schema, a bunch of XMLs, or anything really) with an object that contains configuration data, convenience methods, and so forth. Thus you will in effect have two models - a wrapper model that knows something about Catalyst and your web application, and a generic model that is totally independent of these needs.
Technically, within Catalyst a model is a component - an instance of the model's class belonging to the application. It is important to stress that the lifetime of these objects is per application, not per request.
While the model base class (Catalyst::Model) provides things like config to better integrate the model into the application, sometimes this is not enough, and the model requires access to $c itself.
Situations where this need might arise include:
Interacting with another model
Using per-request data to control behavior
Using plugins from a Model (for example Catalyst::Plugin::Cache).
From a style perspective it's usually considered bad form to make your model "too smart" about things - it should worry about business logic and leave the integration details to the controllers. If, however, you find that it does not make sense at all to use an auxiliary controller around the model, and the model's need to access $c cannot be sidestepped, there exists a power tool called "ACCEPT_CONTEXT".
Multiple controllers are a good way to separate logical domains of your application.
package MyApp::Controller::Login; use base qw/Catalyst::Controller/; sub sign_in : Path("sign-in") { } sub new_password : Path("new-password") { } sub sign_out : Path("sign-out") { } package MyApp::Controller::Catalog; use base qw/Catalyst::Controller/; sub view : Local { } sub list : Local { } package MyApp::Controller::Cart; use base qw/Catalyst::Controller/; sub add : Local { } sub update : Local { } sub order : Local { }
Note that you can also supply attributes via the Controller's config so long as you have at least one attribute on a subref to be exported (:Action is commonly used for this) - for example the following is equivalent to the same controller above:
package MyApp::Controller::Login; use base qw/Catalyst::Controller/; __PACKAGE__->config( actions => { 'sign_in' => { Path => 'sign-in' }, 'new_password' => { Path => 'new-password' }, 'sign_out' => { Path => 'sign-out' }, }, ); sub sign_in : Action { } sub new_password : Action { } sub sign_out : Action { }
Whenever you call $c->component("Foo") you get back an object - the instance of the model. If the component supports the ACCEPT_CONTEXT method instead of returning the model itself, the return value of $model->ACCEPT_CONTEXT( $c ) will be used.
$model->ACCEPT_CONTEXT( $c )
This means that whenever your model/view/controller needs to talk to $c it gets a chance to do this when it's needed.
A typical ACCEPT_CONTEXT method will either clone the model and return one with the context object set, or it will return a thin wrapper that contains $c and delegates to the per-application model object.
Generally it's a bad idea to expose the context object ($c) in your model or view code. Instead you use the ACCEPT_CONTEXT subroutine to grab the bits of the context object that you need, and provide accessors to them in the model. This ensures that $c is only in scope where it is needed which reduces maintenance and debugging headaches. So, if for example you needed two Catalyst::Model::DBIC::Schema models in the same Catalyst model code, you might do something like this:
__PACKAGE__->mk_accessors(qw(model1_schema model2_schema)); sub ACCEPT_CONTEXT { my ( $self, $c, @extra_arguments ) = @_; $self = bless({ %$self, model1_schema => $c->model('Model1')->schema, model2_schema => $c->model('Model2')->schema }, ref($self)); return $self; }
This effectively treats $self as a prototype object that gets a new parameter. @extra_arguments comes from any trailing arguments to $c->component( $bah, @extra_arguments ) (or $c->model(...), $c->view(...) etc).
$c->component( $bah, @extra_arguments )
In a subroutine in the model code, we can then do this:
sub whatever { my ($self) = @_; my $schema1 = $self->model1_schema; my $schema2 = $self->model2_schema; ... }
Note that we still want the Catalyst models to be a thin wrapper around classes that will work independently of the Catalyst application to promote reusability of code. Here we might just want to grab the $c->model('DB')->schema so as to get the connection information from the Catalyst application's configuration for example.
The life time of this value is per usage, and not per request. To make this per request you can use the following technique:
Add a field to $c, like my_model_instance. Then write your ACCEPT_CONTEXT method to look like this:
sub ACCEPT_CONTEXT { my ( $self, $c ) = @_; if ( my $per_request = $c->my_model_instance ) { return $per_request; } else { my $new_instance = bless { %$self, c => $c }, ref($self); Scalar::Util::weaken($new_instance->{c}); # or we have a circular reference $c->my_model_instance( $new_instance ); return $new_instance; } }
For a similar technique to grab a new component instance on each request, see Catalyst::Component::InstancePerContext.
In addition to the Model, View, and Controller components, there's a single class that represents your application itself. This is where you configure your application, load plugins, and extend Catalyst.
package MyApp; use strict; use parent qw/Catalyst/; use Catalyst qw/-Debug ConfigLoader Static::Simple/; MyApp->config( name => 'My Application', # You can put anything else you want in here: my_configuration_variable => 'something', ); 1;
In older versions of Catalyst, the application class was where you put global actions. However, as of version 5.66, the recommended practice is to place such actions in a special Root controller (see "Actions", below), to avoid namespace collisions.
The name of your application.
Optionally, you can specify a root parameter for templates and static data. If omitted, Catalyst will try to auto-detect the directory's location. You can define as many parameters as you want for plugins or whatever you need. You can access them anywhere in your application via $context->config->{$param_name}.
Catalyst automatically blesses a Context object into your application class and makes it available everywhere in your application. Use the Context to directly interact with Catalyst and glue your "Components" together. For example, if you need to use the Context from within a Template Toolkit template, it's already there:

Welcome to [% c.config.name %]!

As illustrated in our URL-to-Action dispatching example, the Context is always the second method parameter, behind the Component object reference or class name itself. Previously we called it $context for clarity, but most Catalyst developers just call it $c:
sub hello : Global { my ( $self, $c ) = @_; $c->res->body('Hello World!'); }
The Context contains several important objects:
$c->request $c->req # alias
The request object contains all kinds of request-specific information, like query parameters, cookies, uploads, headers, and more.
$c->req->params->{foo}; $c->req->cookies->{sessionid}; $c->req->headers->content_type; $c->req->base; $c->req->uri_with( { page = $pager->next_page } );
$c->response $c->res # alias
The response is like the request, but contains just response-specific information.
$c->res->body('Hello World'); $c->res->status(404); $c->res->redirect('http://oook.de');
$c->config $c->config->{root}; $c->config->{name};
$c->log $c->log->debug('Something happened'); $c->log->info('Something you should know');
$c->stash $c->stash->{foo} = 'bar'; $c->stash->{baz} = {baz => 'qox'}; $c->stash->{fred} = [qw/wilma pebbles/];
and so on.
The last of these, the stash, is a universal hash for sharing data among application components. For an example, we return to our 'hello' action:
sub hello : Global { my ( $self, $c ) = @_; $c->stash->{message} = 'Hello World!'; $c->forward('show_message'); } sub show_message : Private { my ( $self, $c ) = @_; $c->res->body( $c->stash->{message} ); }
Note that the stash should be used only for passing data in an individual request cycle; it gets cleared at a new request. If you need to maintain persistent data, use a session. See Catalyst::Plugin::Session for a comprehensive set of Catalyst-friendly session-handling tools.
You've already seen some examples of actions in this document: subroutines with :Path and :Local attributes attached. Here, we explain what actions are and how these attributes affect what's happening.
When Catalyst processes a webpage request, it looks for actions to take that will deal with the incoming request and produce a response such as a webpage. You create these actions for your application by writing subroutines within your controller and marking them with special attributes. The attributes, the namespace, and the function name determine when Catalyst will call the subroutine.
These action subroutines call certain functions to say what response the webserver will give to the web request. They can also tell Catalyst to run other actions on the request (one example of this is called forwarding the request; this is discussed later).
Action subroutines must have a special attribute on to show that they are actions - as well as marking when to call them, this shows that they take a specific set of arguments and behave in a specific way. At startup, Catalyst looks for all the actions in controllers, registers them and creates Catalyst::Action objects describing them. When requests come in, Catalyst chooses which actions should be called to handle the request.
(Occasionally, you might use the action objects directly, but in general, when we talk about actions, we're talking about the subroutines in your application that do things to process a request.)
You can choose one of several attributes for action subroutines; these specify which requests are processed by that subroutine. Catalyst will look at the URL it is processing, and the actions that it has found, and automatically call the actions it finds that match the circumstances of the request.
The URL (for example http://localhost:3000/foo/bar) consists of two parts, the base, describing how to connect to the server (http://localhost:3000/ in this example) and the path, which the server uses to decide what to return (foo/bar). Please note that the trailing slash after the hostname[:port] always belongs to base and not to the path. Catalyst uses only the path part when trying to find actions to process.
Depending on the type of action used, the URLs may match a combination of the controller namespace, the arguments passed to the action attribute, and the name of the subroutine.
Controller namespaces
The namespace is a modified form of the component's class (package) name. This modified class name excludes the parts that have a pre-defined meaning in Catalyst ("MyApp::Controller" in the above example), replaces "::" with "/", and converts the name to lower case. See "Components" for a full explanation of the pre-defined meaning of Catalyst component class names.
Overriding the namespace
Note that __PACKAGE__->config->(namespace => ... ) can be used to override the current namespace when matching. So:
__PACKAGE__->config->(namespace => ... )
package MyApp::Controller::Example;
would normally use 'example' as its namespace for matching, but if this is specially overridden with
__PACKAGE__->config( namespace => 'thing' );
it matches using the namespace 'thing' instead.
Application-Wide Actions
MyApp::Controller::Root, as created by the catalyst.pl script, will typically contain actions which are called for the top level of the application (e.g. http://localhost:3000/):
package MyApp::Controller::Root; use base 'Catalyst::Controller'; # Sets the actions in this controller to be registered with no prefix # so they function identically to actions created in MyApp.pm __PACKAGE__->config( namespace => ''); sub default : Path { my ( $self, $context ) = @_; $context->response->status(404); $context->response->body('404 not found'); } 1;
The code
__PACKAGE__->config( namespace => '' );
makes the controller act as if its namespace is empty. As you'll see below, an empty namespace makes many of the URL-matching attributes, such as :Path and :Local match at the start of the URL path (i.e. the application root).
Catalyst supports several types of actions. These mainly correspond to ways of matching a URL to an action subroutine. Internally, these matching types are implemented by Catalyst::DispatchType-derived classes; the documentation there can be helpful in seeing how they work.
They will all attempt to match the start of the path. The remainder of the path is passed as arguments.
Namespace-prefixed (:Local)
package MyApp::Controller::My::Controller; sub foo : Local { }
Matches any URL beginning with> http://localhost:3000/my/controller/foo. The namespace and subroutine name together determine the path.
Root-level (:Global)
package MyApp::Controller::Foo; sub bar : Global { my ($self, $c) = @_; $c->res->body( $c->res->body('sub bar in Controller::Foo triggered on a request for ' . $c->req->uri)); }
Matches http://localhost:3000/bar - that is, the action is mapped directly to the method name, ignoring the controller namespace.
:Global always matches from the application root: it is simply shorthand for :Path('/methodname'). :Local is shorthand for :Path('methodname'), which takes the controller namespace as described above.
Usage of the Global handler is rare in all but very old Catalyst applications (e.g. before Catalyst 5.7). The use cases where Global used to make sense are now largely replaced by the Chained dispatch type, or by empty Path declarations on an controller action. Global is still included in Catalyst for backwards compatibility, although legitimate use-cases for it may still exist.
Changing handler behaviour: eating arguments (:Args)
:Args is not an action type per se, but an action modifier - it adds a match restriction to any action it's provided to, additionally requiring as many path parts as are specified for the action to be matched. For example, in MyApp::Controller::Foo,
sub bar :Local
would match any URL starting /foo/bar. To restrict this you can do
sub bar :Local :Args(1)
to only match URLs starting /foo/bar/* - with one additional path element required after 'bar'.
NOTE that adding :Args(0) and omitting :Args are not the same thing.
:Args(0) means that no arguments are taken. Thus, the URL and path must match precisely.
No :Args at all means that any number of arguments are taken. Thus, any URL that starts with the controller's path will match. Obviously, this means you cannot chain from an action that does not specify args, as the next action in the chain will be swallowed as an arg to the first!
Literal match (:Path)
Path actions match things starting with a precise specified path, and nothing else.
Path actions without a leading forward slash match a specified path relative to their current namespace. This example matches URLs starting with http://localhost:3000/my/controller/foo/bar:
package MyApp::Controller::My::Controller; sub bar : Path('foo/bar') { }
Path actions with a leading slash ignore their namespace, and match from the start of the URL path. Example:
package MyApp::Controller::My::Controller; sub bar : Path('/foo/bar') { }
This matches URLs beginning with http://localhost:3000/foo/bar.
Empty Path definitions match on the namespace only, exactly like :Global.
package MyApp::Controller::My::Controller; sub bar : Path { }
The above code matches http://localhost:3000/my/controller.
Actions with the :Local attribute are similarly equivalent to :Path('action_name'):
sub foo : Local { }
is equivalent to
sub foo : Path('foo') { }
Pattern match (:Regex and :LocalRegex)
Status: deprecated. Use Chained methods or other techniques. If you really depend on this, install the standalone Catalyst::DispatchType::Regex distribution.
package MyApp::Controller::My::Controller; sub bar : Regex('^item(\d+)/order(\d+)$') { }
This matches any URL that matches the pattern in the action key, e.g. http://localhost:3000/item23/order42. The '' around the regexp is optional, but perltidy likes it. :)
:Regex matches act globally, i.e. without reference to the namespace from which they are called. So the above will not match http://localhost:3000/my/controller/item23/order42 - use a :LocalRegex action instead.
package MyApp::Controller::My::Controller; sub bar : LocalRegex('^widget(\d+)$') { }
:LocalRegex actions act locally, i.e. the namespace is matched first. The above example would match urls like http://localhost:3000/my/controller/widget23.
If you omit the "^" from either sort of regex, then it will match any depth from the base path:
package MyApp::Controller::Catalog; sub bar : LocalRegex('widget(\d+)$') { }
This differs from the previous example in that it will match http://localhost:3000/my/controller/foo/widget23 - and a number of other paths.
For both :LocalRegex and :Regex actions, if you use capturing parentheses to extract values within the matching URL, those values are available in the $c->req->captures array. In the above example, "widget23" would capture "23" in the above example, and $c->req->captures->[0] would be "23". If you want to pass arguments at the end of your URL, you must use regex action keys. See "URL Path Handling" below.
Chained handlers (:Chained)
Catalyst also provides a method to build and dispatch chains of actions, like
sub catalog : Chained : CaptureArgs(1) { my ( $self, $c, $arg ) = @_; ... } sub item : Chained('catalog') : Args(1) { my ( $self, $c, $arg ) = @_; ... }
to handle a /catalog/*/item/* path. Matching actions are called one after another - catalog() gets called and handed one path element, then item() gets called with another one. For further information about this dispatch type, please see Catalyst::DispatchType::Chained.
sub foo : Private { }
This will never match a URL - it provides a private action which can be called programmatically from within Catalyst, but is never called automatically due to the URL being requested.
Catalyst's :Private attribute is exclusive and doesn't work with other attributes (so will not work combined with :Path or :Chained attributes, for instance).
Private actions can only be executed explicitly from inside a Catalyst application. You might do this in your controllers by calling catalyst methods such as forward or detach to fire them:
$c->forward('foo'); # or $c->detach('foo');
See "Flow Control" for a full explanation of how you can pass requests on to other actions. Note that, as discussed there, when forwarding from another component, you must use the absolute path to the method, so that a private bar method in your MyApp::Controller::Catalog::Order::Process controller must, if called from elsewhere, be reached with $c->forward('/catalog/order/process/bar').
Note: After seeing these examples, you probably wonder what the point is of defining subroutine names for regex and path actions. However, every public action is also a private one with a path corresponding to its namespace and subroutine name, so you have one unified way of addressing components in your forwards.
If present, the special actions index , auto , begin, end and default are called at certain points in the request cycle.
In response to specific application states, Catalyst will automatically call these built-in actions in your application class:
default : Path
This is called when no other action matches. It could be used, for example, for displaying a generic frontpage for the main app, or an error page for individual controllers. Note: in older Catalyst applications you will see default : Private which is roughly speaking equivalent.
default : Private
index : Path : Args (0)
index is much like default except that it takes no arguments and it is weighted slightly higher in the matching process. It is useful as a static entry point to a controller, e.g. to have a static welcome page. Note that it's also weighted higher than Path. Actually the sub name index can be called anything you want. The sub attributes are what determines the behaviour of the action. Note: in older Catalyst applications, you will see index : Private used, which is roughly speaking equivalent.
index : Private
begin : Private
Called at the beginning of a request, once the controller that will run has been identified, but before any URL-matching actions are called. Catalyst will call the begin function in the controller which contains the action matching the URL.
end : Private
Called at the end of a request, after all URL-matching actions are called. Catalyst will call the end function in the controller which contains the action matching the URL.
auto : Private
In addition to the normal built-in actions, you have a special action for making chains, auto. auto actions will be run after any begin, but before your URL-matching action is processed. Unlike the other built-ins, multiple auto actions can be called; they will be called in turn, starting with the application class and going through to the most specific class.
package MyApp::Controller::Foo; sub begin : Private { } sub default : Path { } sub end : Path { }
You can define built-in actions within your controllers as well as on your application class. In other words, for each of the three built-in actions above, only one will be run in any request cycle. Thus, if MyApp::Controller::Catalog::begin exists, it will be run in place of MyApp::begin if you're in the catalog namespace, and MyApp::Controller::Catalog::Order::begin would override this in turn.
sub auto : Private { }
auto, however, doesn't override like this: providing they exist, MyApp::Controller::Root::auto, MyApp::Controller::Catalog::auto and MyApp::Catalog::Order::auto would be called in turn.
Here are some examples of the order in which the various built-ins would be called:
MyApp::Controller::Foo::auto MyApp::Controller::Foo::default # in the absence of MyApp::Controller::Foo::Foo MyApp::Controller::Foo::end
MyApp::Controller::Foo::Bar::begin MyApp::Controller::Foo::auto MyApp::Controller::Foo::Bar::auto MyApp::Controller::Foo::Bar::default # for MyApp::Controller::Foo::Bar::foo MyApp::Controller::Foo::Bar::end
The auto action is also distinguished by the fact that you can break out of the processing chain by returning 0. If an auto action returns 0, any remaining actions will be skipped, except for end. So, for the request above, if the first auto returns false, the chain would look like this:
MyApp::Controller::Foo::Bar::begin MyApp::Controller::Foo::auto # returns false, skips some calls: # MyApp::Controller::Foo::Bar::auto - never called # MyApp::Controller::Foo::Bar::foo - never called MyApp::Controller::Foo::Bar::end
You can also die in the auto action; in that case, the request will go straight to the finalize stage, without processing further actions. So in the above example, MyApp::Controller::Foo::Bar::end is skipped as well.
An example of why one might use auto is an authentication action: you could set up a auto action to handle authentication in your application class (which will always be called first), and if authentication fails, returning 0 would skip any remaining methods for that URL.
Note: Looking at it another way, auto actions have to return a true value to continue processing!
You can pass arguments as part of the URL path, separated with forward slashes (/). If the action is a Regex or LocalRegex, the '$' anchor must be used. For example, suppose you want to handle /foo/$bar/$baz, where $bar and $baz may vary:
sub foo : Regex('^foo$') { my ($self, $context, $bar, $baz) = @_; }
But what if you also defined actions for /foo/boo and /foo/boo/hoo?
sub boo : Path('foo/boo') { .. } sub hoo : Path('foo/boo/hoo') { .. }
Catalyst matches actions in most specific to least specific order - that is, whatever matches the most pieces of the path wins:
/foo/boo/hoo /foo/boo /foo # might be /foo/bar/baz but won't be /foo/boo/hoo
So Catalyst would never mistakenly dispatch the first two URLs to the '^foo$' action.
If a Regex or LocalRegex action doesn't use the '$' anchor, the action will still match a URL containing arguments; however the arguments won't be available via @_, because the Regex will 'eat' them.
Beware! If you write two matchers, that match the same path, with the same specificity (that is, they match the same quantity of the path), there's no guarantee which will actually get called. Non-regex matchers get tried first, followed by regex ones, but if you have, for instance:
package MyApp::Controller::Root; sub match1 :Path('/a/b') { } package MyApp::Controller::A; sub b :Local { } # Matches /a/b
then Catalyst will call the one it finds first. In summary, Don't Do This.
Parameters passed in the URL query string are handled with methods in the Catalyst::Request class. The param method is functionally equivalent to the param method of CGI.pm and can be used in modules that require this.
# http://localhost:3000/catalog/view/?category=hardware&page=3 my $category = $c->req->param('category'); my $current_page = $c->req->param('page') || 1; # multiple values for single parameter name my @values = $c->req->param('scrolling_list'); # DFV requires a CGI.pm-like input hash my $results = Data::FormValidator->check($c->req->params, \%dfv_profile);
You control the application flow with the forward method, which accepts the key of an action to execute. This can be an action in the same or another Catalyst controller, or a Class name, optionally followed by a method name. After a forward, the control flow will return to the method from which the forward was issued.
A forward is similar to a method call. The main differences are that it wraps the call in an eval to allow exception handling; it automatically passes along the context object ($c or $context); and it allows profiling of each call (displayed in the log with debugging enabled).
sub hello : Global { my ( $self, $c ) = @_; $c->stash->{message} = 'Hello World!'; $c->forward('check_message'); # $c is automatically included } sub check_message : Private { my ( $self, $c ) = @_; return unless $c->stash->{message}; $c->forward('show_message'); } sub show_message : Private { my ( $self, $c ) = @_; $c->res->body( $c->stash->{message} ); }
A forward does not create a new request, so your request object ($c->req) will remain unchanged. This is a key difference between using forward and issuing a redirect.
You can pass new arguments to a forward by adding them in an anonymous array. In this case $c->req->args will be changed for the duration of the forward only; upon return, the original value of $c->req->args will be reset.
sub hello : Global { my ( $self, $c ) = @_; $c->stash->{message} = 'Hello World!'; $c->forward('check_message',[qw/test1/]); # now $c->req->args is back to what it was before } sub check_message : Action { my ( $self, $c, $first_argument ) = @_; my $also_first_argument = $c->req->args->[0]; # now = 'test1' # do something... }
As you can see from these examples, you can just use the method name as long as you are referring to methods in the same controller. If you want to forward to a method in another controller, or the main application, you will have to refer to the method by absolute path.
$c->forward('/my/controller/action'); $c->forward('/default'); # calls default in main application
You can also forward to classes and methods.
sub hello : Global { my ( $self, $c ) = @_; $c->forward(qw/MyApp::View:Hello say_hello/); } sub bye : Global { my ( $self, $c ) = @_; $c->forward('MyApp::Model::Hello'); # no method: will try 'process' } package MyApp::View::Hello; sub say_hello { my ( $self, $c ) = @_; $c->res->body('Hello World!'); } sub process { my ( $self, $c ) = @_; $c->res->body('Goodbye World!'); }
This mechanism is used by Catalyst::Action::RenderView to forward to the process method in a view class.
It should be noted that whilst forward is useful, it is not the only way of calling other code in Catalyst. Forward just gives you stats in the debug screen, wraps the code you're calling in an exception handler and localises $c->request->args.
If you don't want or need these features then it's perfectly acceptable (and faster) to do something like this:
sub hello : Global { my ( $self, $c ) = @_; $c->stash->{message} = 'Hello World!'; $self->check_message( $c, 'test1' ); } sub check_message { my ( $self, $c, $first_argument ) = @_; # do something... }
Note that forward returns to the calling action and continues processing after the action finishes. If you want all further processing in the calling action to stop, use detach instead, which will execute the detached action and not return to the calling sub. In both cases, Catalyst will automatically try to call process() if you omit the method.
Catalyst has a built-in http server for testing or local deployment. (Later, you can easily use a more powerful server, for example Apache/mod_perl or FastCGI, in a production environment.)
Start your application on the command line...
...then visit http://localhost:3000/ in a browser to view the output.
You can also do it all from the command line:
script/myapp_test.pl http://localhost/
Catalyst has a number of tools for actual regression testing of applications. The helper scripts will automatically generate basic tests that can be extended as you develop your project. To write your own comprehensive test scripts, Test::WWW::Mechanize::Catalyst is an invaluable tool.
For more testing ideas, see Catalyst::Manual::Tutorial::08_Testing.
Have fun!
Join #catalyst on irc.perl.org. Join #catalyst-dev on irc.perl.org to help with development.
Mailing lists:
http://lists.scsys.co.uk/mailman/listinfo/catalyst http://lists.scsys.co.uk/mailman/listinfo/catalyst-dev
Catalyst Contributors, see Catalyst.pm
This library is free software. You can redistribute it and/or modify it under the same terms as Perl itself.
To install Catalyst::Manual, copy and paste the appropriate command in to your terminal.
cpanm Catalyst::Manual
CPAN shell
perl -MCPAN -e shell install Catalyst::Manual
For more information on module installation, please visit the detailed CPAN module installation guide.


text:
Table of ContentsWorking with branchesOBSOLETE These instructions have been superseded by Using git. OBSOLETE NOTE: The rosegarden svn URL on sourceforge has changed. This page has only been partially updated to reflect that. Usually it is simply a matter of replacing all https://<user>@rosegarden.svn.sourceforge.net/svnroot/rosegarden with svn+ssh://<user>@svn.code.sf.net/p/rosegarden/code Keep this in mind while reading this page… When to branch?To branch or not to branch? The decision whether to branch or not is not really something that follows a strict formula, but you should consider doing your work in a branch if it:
Of these, the only really critical and absolute rule is that you must always exercise all possible caution to try to avoid breaking trunk/, and if you ever anticipate committing half-working code, you should almost certainly do this in a branch. Moving existing code into a branchThe best practice is to think everything out before you begin, realize that you will need to work in a branch, create that branch, and do all your work in there from the beginning. In reality, it is very common for a developer to begin some project without thinking all of this through for one reason or another. Perhaps what was supposed to be simple has turned out to be much more complicated than expected. Maybe a quick hour of code to knock something out is going to turn into a week or more before all the unexpected problems can be sorted out. Sometimes, you will even begin working from and committing to trunk/ without realizing that your work really should have been done in a branch first, and someone will ask you to branch and complete your work there; merging it after whatever controversy is resolved to everyone's satisfaction. This is simple to deal with, if this every happens to you. Simply take a patch of your current working copy before you proceed with creating a branch and checking it out. svn diff > <patch_my_branch> Note: Replace <patch_my_branch> with a real filename of your choosing To avoid causing yourself problems down the line, now that you have taken this patch to use later, you should revert these changes from your working copy of trunk/ before continuing. patch -R -p0 < <patch_my_branch> You can double check that everything worked properly by running svn diff This should produce no output. Note This technique works very well if all of your modifications were to files that were already under version control. If you have already started adding new files, but have not yet put any of them under version control, they will not be included in your patch, and you will need to keep up with them and move them into your working copy of your new branch later on. Unfortunately, svn diff is of no help in this situation. Creating a new branchWhether you are beginning completely from scratch, or you are creating a branch out of existing work you began in trunk/, the next step in this process is to create the branch itself in the Subversion repository. Create a new branch by copying trunk/. For example, for a branch called <my_branch>, do the following (as a single one-line command): svn copy svn+ssh://<user>@svn.code.sf.net/p/rosegarden/code/trunk/rosegarden \ svn+ssh://<user>@svn.code.sf.net/p/rosegarden/code/branches/<my_branch> You can see what branches already exist (so as to get ideas for a new name, perhaps) using svn ls http://svn.code.sf.net/p/rosegarden/code/branches/ (Or you can browse the online Subversion repository at http://sourceforge.net/p/rosegarden/code/) Note: Replace <user> with your SourceForge username and <my_branch> with your branch name. Checking out a branchsvn co <my_branch> The full command to checkout my_branch using username is: svn checkout svn+ssh://<user>@svn.code.sf.net/p/rosegarden/code/branches/<my_branch> <my_branch> Note: Replace <user> with your SourceForge username and <my_branch> with your branch name. After the checkout completes, take note of the revision number for later, so you don't have to dig it back up when it comes time to merge. The last message from Subversion will tell you this piece of information, for example: Checked out revision 10745. Applying your patchIf you took a patch of the work you began in trunk/ then now is the time to apply that patch to your new working copy of your new branch. Simply use patch -p0 < <patch_my_branch> Note: Be sure not to use the -R option in the patch command this time. Replace <patch_my_branch> with the real filename you selected earlier. If you created any files that were not yet under version control, and were not included in that patch, now is the time to move them across into this directory. Now you are ready to commit the beginning of your new branch, and get to work in here! Committing changes to the branchWorking with branches is as easy as working with the trunk. Commit the changes from the root directory of the branch. cd <my_branch> svn commit -m "Text which describes the updates." Merging changes from a branch to trunkFor most branches, you want to keep the merge as simple as possible, and only do this once. Chris Cannam recommends ignoring trunk/ until you are ready to merge, and then doing the merge starting by taking a temporary working copy of trunk/ to get started: $ svn co https://rosegarden.svn.sourceforge.net:/svnroot/rosegarden/trunk/rosegarden \ tmp-working-copy Then change into tmp-working-copy/, and using the revision at which you branched (which you took note of earlier) and the name of your branch, do something like: $ cd tmp-working-copy $ svn merge -r<10208>:HEAD https://rosegarden.svn.sourceforge.net:/svnroot/rosegarden/branches/<my_branch> Note: Replace <my_branch> with your branch and and <10208> with revision number of the branch noted earlier. Resolve conflicts, build, test… Then run svn diff to make sure what you're about to commit looks sane. Then fire away with svn commit Merging changes from trunk to the branchIf you are going to be working on the branch for a long time, you may wish to reduce the number of conflicts you may eventually have to resolve by periodically merging from trunk/ into your branch, and then merging the branch back at the end of its life cycle. You may check the Last Changed revision of the branch with command svn info Let us suppose that the last changed svn version was 8114. Then you would like to merge all changes since svn version 8115. You may do it with command svn merge -r 8115:HEAD https://rosegarden.svn.sourceforge.net/svnroot/rosegarden/trunk/rosegarden If there are no conflicts, you may continue by committing the changes to the branch. svn commit -m "merge from trunk" Note that such a committing does not work if you had conflicts, therefore, resolve conflicts before committing changes. Resolving conflictsA conflict occurs when you try to update your working copy from a repository that has conflicting changes in it. This can happen during the normal course of development, when two different people happen to work in the same place. (One common circumstance is that developer C commits broken changes, and both developers A and B rush in with two slightly different, conflicting fixes.) During a merge, this happens when your branch changes some part of the code that also changed in trunk/, and Subversion cannot decide how to put all the pieces together. When you experience a conflict (such as the real conflict upon which I'm basing this example), recent versions of Subversion will prompt you what to do: Conflict discovered in 'data/rc/rosegardenui.rc'. Select: (p) postpone, (df) diff-full, (e) edit, (h) help for more options: Chris recommends that you just choose p to postpone conflict resolution. (For binary conflicts, you will also get tf and mf for "theirs full" and "mine full" respectively. Which to choose will depend entirely on the circumstances.) (h) help for more options: p --- Merging r10774 through r10874 into 'data/rc': C data/rc/rosegardenui.rc After the conflict, you wind up with several files, similar to these:
Chris works with the plain .c file, which is the original file with the conflicts given in an "alternatives" diff-like form, such as this excerpt: <Action name="file_revert"/> </enable> </State> <<<<<<< .working <State name="have_project_packager"> <enable> <Action name="file_import_project"/> <Action name="file_export_project"/> </enable> </State> ======= >>>>>>> .merge-right.r10874 <State name="have_segments"> <enable> <Action name="move"/> In this case, I apparently removed some code from part of the file that simultaneously changed in trunk/ and Subversion got confused. I can't remember what I did where, or who did what, so while Chris recommends working only with the plain .c file, I have found I can't figure out what I'm looking at in this case. I decided to have a look with Kompare. kompare rosegardenui.rc.merge-left.r10773 rosegardenui.rc.merge-right.r10874 I find the visual presentation easier for getting a real sense of what's going on, although the particular example I happened to have chosen to present here (because it was the first one I had at hand) is not particularly good. This conflict is easy to resolve. In any case, once you have discovered what is going on to your satisfaction, edit the file until you're happy with it, then run svn resolved <filename> to tell Subversion that you have resolved the conflict. Test and commit. Closing a branchWhen a branch is finished with, we usually either delete it if it was very short-lived and uninteresting, svn rm https://<user>@rosegarden.svn.sourceforge.net/svnroot/rosegarden/branches/uninteresting or else move it to the branches/obsolete directory on the Subversion server. If in doubt, do the latter: svn mv https://<user>@rosegarden.svn.sourceforge.net/svnroot/rosegarden/branches/my_branch \ https://<user>@rosegarden.svn.sourceforge.net/svnroot/rosegarden/branches/obsolete/ Example of a planned and focused branch |

subset: commoncrawl


text:
- Home
- Government
- Departments
- Division of Engineering
- Floodplain Management
Floodplain Restoration News Articles
Click HERE to View the 2023 Floodplain Management Progress Report
Protecting Your Property from Flood Hazards
This webpage has been developed to help minimize risk within floodplains, and in order to reduce the amount of flood damage sustained during future flood events. Some areas of Woodbridge Township have been historically susceptible to flooding, and as a result it's important to know how to protect your property from a potential flood event. To learn more about how to protect your home from flooding and low-cost projects you can do yourself, click HERE. Be sure to obtain all necessary permits before construction.
The information found on this webpage should be used as complimentary guidance materials. This webpage is intended to help provide an overview of key information related to flood risk and vulnerability as per, federal, state and local regulations and floodplain mapping. However, this webpage does not create liability on the part of the municipality, or any officer, or employee thereof, for any damage that results from reliance on guidance or determinations made by its use. This webpage can be used to help aid decision-making processes with engineers, ecologists, planners, construction officials, and emergency managers.
For detailed FEMA Flood Insurance Rate Map (FIRM) determinations based on a street address contact the Woodbridge Township Division of Engineering for personal assistance: 732.602.6057
Protect Yourself from Flood Hazards
Prepare for a Potential Flood Event
• Familiarize yourself with how to turn-off the electricity and gas to your house.
• Be aware of alternative evacuation routes from your neighborhood.
• Gather supplies that you might need during a flood event, such as: a "go-bag," battery- powered radio, emergency kit, etc.
• Plan for how you will care for your pets during a potential flood event.
• Create a response plan. Visit www.redcross.org to learn more about developing ways to be better prepared. To learn more about what types of flood hazards impact Woodbridge Township Click HERE.
During and After a Flood Event
• Avoid downed power lines that could pose a serious life-threatening hazard. Report these issues to utility companies immediately.
• Generators should never be operated inside your home or garage.
• Never drive down flooded road ways.
• The Department of Homeland Security has developed a checklist designed to help you properly prepare and recover from a potential evacuation.
Build Responsibly in Flood Hazard Areas
If you are in the market to potentially purchase property, you should examine any possibility of a flood hazard BEFORE YOU BUY & BEFORE YOU BUILD, and the need to have flood insurance to protect yourselves and your property. Flood-proofing techniques vary in size, scale and scope in relation to specific flood hazard conditions. The Homeowner's Guide to Retrofitting (FEMA P-312) and other helpful resources are available for order and / or download at www.fema.gov/media-library. Some retrofitting alternatives might include elevating the structure, constructing engineered flood-proofing measures, and protecting utilities. Be sure to obtain all necessary permits before construction. Contact the Building Department (732-602-6003) and Division of Engineering (732-602-6057) for help designing and permitting projects.
The Township recognizes The New Jersey State Flood Hazard Area (FHA) Control Act Rules, N.J.A.C. 7:13. Please note that in situations where the base flood elevation (BFE) denotes a more protective delineation on the 2014 Preliminary FIRM, the State of New Jersey is using the information as the basis for statewide floodplain development standards. To learn more about the types of N.J. Flood Hazard Area Permit Authorizations CLICK HERE. To view the Township's Municipal Flood Damage Ordinance, CLICK HERE and view Chapter 22 of the General Ordinance. To view the Township's Open Space Conservation & Resilience Zone Ordinance (OSC/R Zone), CLICK HERE (PDF).
Click HERE to access the Township's Floodplain Development Permit Application.
A Floodplain Development Permit is a specific authorization designed in order to comply with Federal, State, and local regulations. A Floodplain Development Permit Application is required if the proposed development is located within a regulatory floodplain, riparian zone, or sensitive environmental area as outlined in the Township's Flood Damage Prevention Ordinance. A community official or the Floodplain Administrator may perform inspections throughout the proposed project, as well as when the project is completed to ensure that the development is compliant with the requirements of the local Flood Damage Prevention Ordinance as well as applicable State and Federal regulations.
The Township of Woodbridge recognizes the Department of Environmental Protection's Inland Flood Protection Rule, which was adopted by the Department on July 17, 2023.
• New Design Flood Elevation (DFE) raises fluvial (non-tidal) flood elevation mapped by FEMA by three (3) feet
• Requires use of future projected precipitation when calculating flood elevations
• Ensures that DEP's Flood Hazard Area permits conform to NJ Uniform Construction Code standards and meet or exceed minimum FEMA National Flood Insurance Program requirements
• Requires stormwater Best Management Practices (BMPs) to be designed to manage runoff for both today's storms and future storms
• Removes use of Rational and Modified Rational methods for stormwater calculations
It's Important to Carry Flood Insurance
Federal law requires that a Flood Insurance Policy be obtained as a condition of a federally backed mortgage or loan that is secured by the structure located in an area of special flood hazard, as per the Effective Flood Insurance Rate Map (FIRM) delineation. Although some areas susceptible to flood risk do not require the purchase of flood insurance, it is recommended in order to best minimize financial vulnerability during a potential flood event.
It's important to carry flood insurance even if you are not federally required to do so. According to FEMA, a structure located in the Special Flood Hazard Area has a 26% annual chance of experiencing a 100-year flood event over the course of a 30 year mortgage. A property not in a Special Flood Hazard Area (SFHA) may be damaged by a flood greater than that predicted on a flood study, such as a FIRM or state delineation. According to FEMA nearly 25% of all National Flood Insurance Program flood insurance claims come from policy holders outside of federally mapped Special Flood Hazard Areas. Learn more about flood insurance policies available through the NFIP, which could offer lower-cost coverage for structures mapped outside the SFHA.
Most homeowner's insurance policies do not cover flooding. Don't wait until storm season to obtain a policy. It typically takes approximately 30 days for a flood insurance policy to take effect. To learn more about flood insurance and to find out how to obtain a policy visit: www.FloodSmart.gov.
Know Your Flood Hazard
Woodbridge Township has areas of special flood hazards located in the AE, A, Coastal A, and VE zones. You can locate Special Flood Hazard Areas in your neighborhood by looking at the Flood Insurance Maps at FEMA's Map Service Center or by visiting our FEMA Flood Zones page by clicking HERE. Woodbridge Township contains areas of tidal and fluvial flooding. Never drive down flooded roadways. To view a real-time tide gauge for NOAA's Sandy Hook Station, click HERE. To view real-time tide predications at Woodbridge Creek Click HERE. To learn more about federally regulated FEMA flood zones, CLICK HERE.
The Township of Woodbridge participated in updating the Middlesex County Hazard Mitigation Plan. The plan is designed to help identify local weaknesses and assess ways to potentially combat those issues. Thus, the overall outcome of the plan's development to reduce devastating effects of future storm events and other natural hazards. To view the Middlesex County Hazard Mitigation - Appendix 25: Township of Woodbridge, CLICK HERE.
CLICK HERE for the Woodbridge Township Interactive Flood Viewer, which shows:
2010 Effective F.I.R.M.
2014 Preliminary F.I.R.M.
Please note that the Woodbridge Township Flood Viewer should only be used as a reference. For further flood zone clarification or to request a flood zone designation letter for your property, please contact Thomas C. Flynn, M.P.A., CFM in the Woodbridge Township Division of Engineering.
"Region 2 Coastal Analysis and Mapping" is a great resource to compare the effective and revised FEMA flood hazard data available for properties in the community.
Protecting Our Natural Floodplain
Only rain goes down the storm drain. The ability for storm drain systems to function correctly directly relates to minimizing the flood inundation, potential damage sustained during strong rain events, and the reduction of non-point source pollution into our waterways. Natural habitats are the definition of resilient infrastructure, as they are more readily able to rebound after powerful storm events. In addition to providing flood storage capacity, these areas are havens for safeguarding the existing benefits associated with healthy natural areas, such as filtration of nutrient runoff and biodiversity. To learn more about the beneficial functions of natural floodplains, CLICK HERE (PDF).
Woodbridge Township wins NJAFM 2017 Outstanding Floodplain Management Award
Floodplain Restoration
New Jersey Association for Floodplain Management (NJAFM) awarded Woodbridge Township NFAFM's 2017 Outstanding Floodplain Management Award! This award is given annually to recognize an outstanding floodplain management program, project, or activity in New Jersey. The Township has been chosen for effectively helping people escape from harm's way through the Blue Acres program, and additionally focusing on floodplain restoration. The NJAFM Board recognizes the Township's dedication to safety, floodplain management, and progressively working to restore natural floodplain function and habitat with partners from Rutgers Cooperative Extension Wildlife Conservation and Management Program.Click here to learn more about the Townships Roots For Rivers initiative.
The Township of Woodbridge participates in the New Jersey Coastal Coalition. Click HERE to learn more.
Scientific American Write-Up:
To learn more about Woodbridge Township's innovative approaches to floodplain restoration featured in Scientific American CLICK HERE. Floodplain restoration helps to minimize risks within hazardous floodplains, aids in reducing the amount of flood damage sustained during future flood events, and enhances ecological integrity.
Flood Protection Information Library
Click item below to download and view document
- Flood Protection Information Documents cataloged and available at the Woodbridge Main Library
- Above The Flood: Elevating Your Floodprone House (PDF)
- Answers to Questions About the National Flood Insurance Program (PDF)
- Coastal Construction Manual (PDF)
- Elevated Residential Structures (PDF)
- Mandatory Purchase of Flood Insurance Guidelines (PDF)
- Mitigation of Flood and Erosion Damage to Residential Buildings in Coastal Areas (PDF)
- Protecting Building Utility Systems From Flood Damage (PDF)
- Protecting Floodplain Resources (PDF)
- Protecting Manufactured Homes From Floods and Other Hazards (PDF)
- Reducing Damage from Localized Flooding (PDF)
- Open Space and Floodplain Restoration Plan (PDF)
- Woodbridge River Floodplain Baseline Ecological Monitoring Report
- Woodbridge River Hydrologic Modeling Report
Elevation Certificates
- 6000 Riverside Dr. - Inbound Guardhouse (PDF)
- 6000 Riverside Dr. - GatewayBldg (PDF)
- 6000 Riverside Dr. - StairTower (PDF)
- 6000 Riverside Dr. - Outbound Guardhouse (PDF)
- 350 Riverside Dr. - Vehicle Maintenance Garage (PDF)
- 100 Essex Ave. East (PDF)
- 10 Green St. (PDF)
- 84 Crampton Ave. (PDF)
- 1550 St. Georges Ave. (PDF)


text:
- Because mass brands are no longer limited by price point, service opportunities and design, mass beauty is becoming a key destination for all beauty shoppers—all because the channel is responding to what consumers are seeking.
- Although skin care is one of the top drivers at mass, nail and hair care are pushing innovation with new segments and enjoyable offerings.
- Social media continues to be incredibly important in connecting with consumers, helping to level the playing field for all beauty brands.
- Engagement is at the top of list for gaining loyal customers, whether that is through store promotions, online interactions, giveaways or other connection opportunities.
There are many things I love about the summer season. Beach vacations. Open-toed shoes. And the HBA Global Expo. Every year that I attend the HBA conferences, I see leaders of the industry, meet beauty entrepreneurs, and learn something—actually, usually many things. While this typically happens over the course of three days, it also happens simultaneously during a 75-minute session that I have the privilege to moderate. At the 2013 HBA, I was once again given the opportunity to lead the session on "The Changing Face of Beauty Distribution," and for the fourth year in a row, I got to pick the brains of amazing retailers and brand builders, this year with the theme of mass distribution.
According to The NPD Group, the U.S. prestige market beauty segment (defined as department stores) grew faster in 2012 (versus 2011) than mass market beauty (defined as food, drug and mass, excluding Walmart); specifically, 7% versus 3%. [Globally, according to Euromonitor International in its June 2013 State of the Industry report, mass cosmetics were at the heart of the growth story in 2012, fueling more than $16 billion of growth in absolute terms.] And however numbers and data is parsed, exciting news is coming from mass—exciting launches, and celebrity launches in particular; shifts in teams (Ulta's CEO change, for example); and incredibly innovative retail concepts, including the Look Boutique, Target's The Shops at Target, and more. There is definitely a wealth of things happening in beauty at mass.
Mass Beauty Today
But really, what is mass? It used to be that mass was defined by price point, but today, beauty brands such as L'Oréal offer products at mass priced well above $20, the usual cut-off point for prestige/premium/luxury. Mass also used to be defined by the service offered by advisers at department store beauty counters. But today, Target has launched its Beauty Concierge services in stores in Illinois, California, Minnesota, Washington, D.C. and beyond.
Further, mass, in terms of products and brands, used to be defined by channel. But today, the Look Boutique, located in Duane Reade and Walgreens locations, would not define itself as mass. Finally, mass used to be defined by the lack of design. But today, mass borrows from the prestige channel with exclusive design partnerships.
So, back to our question—what is mass beauty today?
This is the first thing I asked the session's panelists: Marcia Gaynor, general merchandise manager, beauty, Duane Reade/Walgreens; Christina Hennington, vice president, merchandising, beauty and personal care, Target; and Ido Leffler, co-founder, Yes to Inc.
To paraphrase Hennington, asking this question is really talking to ourselves. As she pointed out, "Channel words are industry terms, not consumer-facing terms. Who cares what the label is?" Because, indeed, the consumer will buy where she wants to buy, which is usually where it's convenient to buy.
Gaynor picked up the thought, making a clear differentiation between Duane Reade, which represents true mass, and the Look Boutiques, which offer personalized beauty services. Perhaps, in the end, the level of service is what defines the experience. The traditional "prestige" expectations involve education, samples, makeover events—all experiences that happen at the Look Boutique. Hence the consumer will find brands there that she would not expect to find in a traditional mass outlet, Gaynor explained.
The next question for the panel was about which category is driving growth. Having just come from the WWD Beauty Summit and heard Marla Malcolm Beck, the owner of Bluemercury, implore her vendors "No more skin care," it definitely seemed like topic ripe for opinions and discussion. Hennington and Gaynor agreed that skin care is still the focus of beauty at mass, with Hennington calling it "pivotal." The bottom line is, skin care is the segment that drives the most loyalty in the long term.
However, skin care, at mass, is not where most of the growth is happening, nor where the most innovation is coming from. Growth is coming from the nail care segment—likely driven by the reigning economic conditions. Indeed, nails are an easy way for consumers to do something for themselves, to feel happy without spending a lot of dollars.
An infusion of innovation is also coming from hair care. The hair care category is becoming increasingly segmented, and it is, in some ways, becoming more like skin care (anti-aging conditioners, anyone?). This reminds me of another comment made by Malcolm Beck at the WWD Beauty Summit, a statement to the effect that hair care needed to become even more segmented. Forget about shampoo for colored hair—we need shampoo for dry colored hair, shampoo for oily colored hair, and so on.
Touching on an always-hot topic, Hennington brought up the naturals segment, which is "working really well for Target." For her customer, Hennington said, this segment is not a trend but represents, instead, a lifestyle choice.
Leffler was happy to hear her say this, and of course agrees. A distinct representative of the naturals segment, Yes to Inc. is now one of largest natural beauty brands in the mass segment. Yes to Inc. represents 55+ products in 25,000 stores, in 29+ countries, giving rise to audience questions, including how did you do it? Why were you successful? And why did you decide to specifically launch in the mass channel?
To that last question, Leffler deadpanned, "We were amazingly smart." But also, the mass channel is where they had an "in"—an individual who vouched for the brand and made an introduction, to Walgreens buyers. So, Walgreens is where Yes To went.
"I was 28 years old, and this was the biggest meeting of my life," Leffler recalled. "We presented a deck we thought answered all their questions." And one thing led to another. A brand at the right place, at the right time. The naturals category was growing, and Yes to Inc. helped to shape that category. It innovated not only with products but with strategy, being among the first natural brands to do price promotions. When asked about the secret to his success, Leffler talked about the personal involvement of the founders, including noting, "We can never win on the numbers [he says, referring to multinational-owned brands], but we can out-relationship them."
With pop and celebrity culture also becoming so pervasive in society today, questions of celebrities and endorsements were also an exciting discussion for the panel, in particular because of the shifting role that celebrities have been playing in the beauty industry lately—including at mass. In the past, a celebrity was hire as a spokesperson for a large beauty brand. The examples are almost countless, but I find two of particular interest: Katie Holmes because of the fairly intense foray into the beauty industry and Bobbi Brown Cosmetics, which announced Katie Holmes as the brand's first-ever celebrity face in 2012.
More recently, celebrities are playing a role as beauty entrepreneurs. Here again I think of Katie Holmes, but this time with Alterna, the hair care brand of which she is now part owner. Think also of Jennifer Aniston and Living Proof. Or think of the latest celebrity launches, including Nuance by Salma Hayek for CVS and Flower by Drew Barrymore for Walmart.
Gaynor's response points back to the brands and products: "In NYC, celebrity endorsements mean nothing; [the beauty consumer] wants what she wants," she said. And Hennington agreed, adding that the Target consumer wants credibility—and that's not necessarily in the name of an actress on a beauty product but rather that of a professional makeup artist, i.e. someone that knows about the product. Leffler added that in terms of driving sales, while celebrities might be nice to have, the true power lies with the media; specifically, with Dr. Oz, Yes to Inc. has been on the show multiple times, and, according to Leffler, each time the product being discussed sold out while Leffler was on air.
Wrapping it up, the panel ended with two key takeaways; the first from Hennington. When asked what it takes for a brand to be in Target, she countered with the million-dollar question: "What is your reason for being?" Brands need to be "super articulate about [their] value proposition; don't be more of the same."
And, for the second takeaway: "Social media is a godsend for the small to medium brand," commented Leffler. It allows you to level the playing field with the big guys, helping to democratize the beauty industry. If you are a small brand, look at what your very large competitors are doing on social media and copy them. If you do that, you will likely realize that people love free stuff. So use social media to sample and do giveaways, Leffler encouraged. Just remember, he then cautioned, "Authenticity wins... Right after the free stuff."
Ada Polla is the co-creator of the Swiss antioxidant skin care line Alchimie Forever, which launched in the U.S. in 2004. Her strategic focus and implementation have yielded double-digit annual revenue growth for the company. She holds an MBA from Georgetown University, majored in art history and political science at Harvard University and graduated magna cum laude with a Bachelor of Arts degree in 1999. She is also a GCI magazine editorial advisor.


text:
A Landlord who wants to receive payments via EFT must register themselves as a Maricopa County Vendor at: https://azdom-vss-ext.hostams.com/PRDVSS2X1/Advantage4. During this registration, bank information will need to be provided. After registration is complete, a $0.00 prenote test will be sent to your bank. This prenote begins the "test cycle" to ensure that the information provided was accurately entered in the financial system. It takes approximately 9 days to complete this test cycle (the account will be on "hold payment" status during the prenote test). If there are no problems with the test cycle, EFT payments will begin thereafter.
Show All Answers
CCRA applications are only accepted from tenants/renters, and not from landlords. Please direct your tenant/renter to visit the County CCRA website for information on how to apply at https://www.maricopa.gov/5691/Emergency-Rental-Assistance.
A Landlord can either provide a W9 to the renter applicant or register as a County vendor at: a Maricopa County Vendor at: https://azdom-vss-ext.hostams.com/PRDVSS2X1/Advantage4. W9s and/or registration as a County vendor is required for a CCRA payment to be made to a Landlord. Maricopa County is issuing a payment (income) to a landlord, which according to the U.S. Internal Revenue Service (IRS) requires the County to provide the Landlord with a 1099 Form. The W9 and/or registration as a County vendor provides the detailed information (including Social Security Number and/or Employer Identification Number) to ensure the landlord is a valid entity and allows checks to be issued to the Landlord.
The Landlord Verification Form is required as it validates from the landlord which months' rent are owed and/or due from the tenant as well as provides the Landlord's contact information and payment address.
If you have already completed a Landlord Verification Form for a tenant once before, and they are requesting you to do it again this is due to them requesting an additional assistance payment. The Landlord Verification Form is required to verify which months' rent is owed and/or due. However, the W9 and/or vendor registration is not required again as you have already received payment from Maricopa County, and as such are a registered vendor.
The Landlord Verification Form must still be completed for each individual tenant requesting CCRA. This form verifies which months' rent is owed and/or due. If the tenant is approved for CCRA, vendor registration will be verified during the payment process. If it is determined that a Landlord is not registered as a vendor, then the application will be returned to the tenant's case worker and tenant and/or case worker will notify you that a W9 form or registration as a County vendor is required
Due to the large volume of CCRA payments, we are unable to provide additional information regarding specific tenants or CCRA payment amounts. Please request CCRA status from your tenant directly.
Upon tenant final CCRA approval from Maricopa County, a Landlord can expect a payment within 10 days. If an email is provided on the Landlord Verification Form, the Landlord will receive an email upon check issuance.
Due to the large volume of CCRA payments, we are unable to provide additional information regarding specific tenants or CCRA payment amounts. If you have received a check issuance notification, the check will be mailed to the remittance address you listed on the Landlord Verification Form, and can be expected to be received based on typical United States Postal Service processing timeframes.


text:
Designed for a range of watersports, the ALTOis a lightweight, compact, inflatable flotation device worn around the waist. Manually operated, the inflatable tube is released from the waist pack and then supports the user under the arms and around the chest. ALTO offers users such as SUP, Fishermen and small boat participants a simple, easy to use, tiny inflatable pack, that feels invisible when worn, yet is certified as a 50N Buoyancy Aid.
- Huge 75N Buoyancy
- Compact and Lightweight
- Adjustable waist belt for simple close fit
- Can be worn on Front or Back
- Manually Activated – 16g CO2 Cylinder
- ISO12402-5 Approved – 50N Buoyancy Aid
- Lume-On™ Bladder Illumination Light Optional
- Whistle Optional
- Waist: 70-145cm (27.5" - 57")
- Product weight: 376g (13.3oz)
- Product weight: 376g (13.3oz)
- ISO12402-5 50N Buoyancy Aid
- ISO12402-6 Special Purpose Buoyancy Aid
ALTO is approved for adult users only (aged 16 years+) weighing over 40kg. This device is manual inflation only and requires secondary donning.
Application: Swimmers only, sheltered waters help at hand, limited protection against drowning, not a lifejacket. Trained users only, requires secondary donning in the water. Minimum buoyancy when inflated 75N.


text:
Got My Raspberry Pi Up and Running
I say that as if it was hard. Actually, it was pretty dang easy to get the OS (a Linux variant) loaded on the memory card. Seems to work fine -- you can see I have Coyote Blog up in the browser. I am playing with it because I am looking for something to control signaling and other systems on a model railroad. I am more likely to use some kind of Arduino setup, but I wanted to play around with Python on Raspberry Pi as well.
Here is the card. The top wire is a micro-USB 5v power connector. Clockwise from that is a 32GB SD card (for memory), a bunch of empty programmable pins for I/O on the upper right of the board, the composite video connector and audio headphone out, two USB ports with my wireless keyboard connector, the network cable, and on the left the HDMI cable for video out (don't know yet if it has audio out over HDMI). As in the Arduino community, there are already daughter boards for the pin-outs with breadboards, motor controllers, and other gizmos.


text:
Daily Readings for Thursday, July 11, 2024
- Morning Psalms 116; 147:12-20
- First Reading Deuteronomy 3:18-28
- Second Reading Romans 9:19-33
- Gospel Reading Matthew 24:1-14
- Evening Psalms 26; 130
Morning Psalm 116
1 I love the LORD, because he has heard
my voice and my supplications.
2 Because he inclined his ear to me,
therefore I will call on him as long as I live.
3 The snares of death encompassed me;
the pangs of Sheol laid hold on me;
I suffered distress and anguish.
4 Then I called on the name of the LORD:
"O LORD, I pray, save my life!"
5 Gracious is the LORD, and righteous;
our God is merciful.
6 The LORD protects the simple;
when I was brought low, he saved me.
7 Return, O my soul, to your rest,
for the LORD has dealt bountifully with you.
8 For you have delivered my soul from death,
my eyes from tears,
my feet from stumbling.
9 I walk before the LORD
in the land of the living.
10 I kept my faith, even when I said,
"I am greatly afflicted";
11 I said in my consternation,
"Everyone is a liar."
12 What shall I return to the LORD
for all his bounty to me?
13 I will lift up the cup of salvation
and call on the name of the LORD,
14 I will pay my vows to the LORD
in the presence of all his people.
15 Precious in the sight of the LORD
is the death of his faithful ones.
16 O LORD, I am your servant;
I am your servant, the child of your serving girl.
You have loosed my bonds.
17 I will offer to you a thanksgiving sacrifice
and call on the name of the LORD.
18 I will pay my vows to the LORD
in the presence of all his people,
19 in the courts of the house of the LORD,
in your midst, O Jerusalem.
Praise the LORD!
Morning Psalm 147:12-20
12 Praise the Lord, O Jerusalem!
Praise your God, O Zion!
13 For he strengthens the bars of your gates;
he blesses your children within you.
14 He grants peace within your borders;
he fills you with the finest of wheat.
15 He sends out his command to the earth;
his word runs swiftly.
16 He gives snow like wool;
he scatters frost like ashes.
17 He hurls down hail like crumbs —
who can stand before his cold?
18 He sends out his word, and melts them;
he makes his wind blow, and the waters flow.
19 He declares his word to Jacob,
his statutes and ordinances to Israel.
20 He has not dealt thus with any other nation;
they do not know his ordinances.
Praise the Lord!
First Reading Deuteronomy 3:18-28
18At that time, I charged you as follows: "Although the LORD your God has given you this land to occupy, all your troops shall cross over armed as the vanguard of your Israelite kin. 19Only your wives, your children, and your livestock - I know that you have much livestock - shall stay behind in the towns that I have given to you. 20When the LORD gives rest to your kindred, as to you, and they too have occupied the land that the LORD your God is giving them beyond the Jordan, then each of you may return to the property that I have given to you." 21And I charged Joshua as well at that time, saying: "Your own eyes have seen everything that the LORD your God has done to these two kings; so the LORD will do to all the kingdoms into which you are about to cross. 22Do not fear them, for it is the LORD your God who fights for you."
23At that time, too, I entreated the LORD, saying: 24"O Lord GOD, you have only begun to show your servant your greatness and your might; what god in heaven or on earth can perform deeds and mighty acts like yours! 25Let me cross over to see the good land beyond the Jordan, that good hill country and the Lebanon." 26But the LORD was angry with me on your account and would not heed me. The LORD said to me, "Enough from you! Never speak to me of this matter again! 27Go up to the top of Pisgah and look around you to the west, to the north, to the south, and to the east. Look well, for you shall not cross over this Jordan. 28But charge Joshua, and encourage and strengthen him, because it is he who shall cross over at the head of this people and who shall secure their possession of the land that you will see."
Second Reading Romans 9:19-33
19You will say to me then, "Why then does he still find fault? For who can resist his will?" 20But who indeed are you, a human being, to argue with God? Will what is molded say to the one who molds it, "Why have you made me like this?" 21Has the potter no right over the clay, to make out of the same lump one object for special use and another for ordinary use? 22What if God, desiring to show his wrath and to make known his power, has endured with much patience the objects of wrath that are made for destruction; 23and what if he has done so in order to make known the riches of his glory for the objects of mercy, which he has prepared beforehand for glory - 24including us whom he has called, not from the Jews only but also from the Gentiles? 25As indeed he says in Hosea, "Those who were not my people I will call 'my people,' and her who was not beloved I will call 'beloved.'"
26"And in the very place where it was said to them, 'You are not my people,' there they shall be called children of the living God."
27And Isaiah cries out concerning Israel, "Though the number of the children of Israel were like the sand of the sea, only a remnant of them will be saved; 28for the Lord will execute his sentence on the earth quickly and decisively." 29And as Isaiah predicted, "If the Lord of hosts had not left survivors to us, we would have fared like Sodom and been made like Gomorrah."
30What then are we to say? Gentiles, who did not strive for righteousness, have attained it, that is, righteousness through faith; 31but Israel, who did strive for the righteousness that is based on the law, did not succeed in fulfilling that law. 32Why not? Because they did not strive for it on the basis of faith, but as if it were based on works. They have stumbled over the stumbling stone, 33as it is written, "See, I am laying in Zion a stone that will make people stumble, a rock that will make them fall, and whoever believes in him will not be put to shame."
Gospel Reading Matthew 24:1-14
1As Jesus came out of the temple and was going away, his disciples came to point out to him the buildings of the temple. 2Then he asked them, "You see all these, do you not? Truly I tell you, not one stone will be left here upon another; all will be thrown down."
3When he was sitting on the Mount of Olives, the disciples came to him privately, saying, "Tell us, when will this be, and what will be the sign of your coming and of the end of the age?" 4Jesus answered them, "Beware that no one leads you astray. 5For many will come in my name, saying, 'I am the Messiah!' and they will lead many astray. 6And you will hear of wars and rumors of wars; see that you are not alarmed; for this must take place, but the end is not yet. 7For nation will rise against nation, and kingdom against kingdom, and there will be famines and earthquakes in various places: 8all this is but the beginning of the birthpangs.
9"Then they will hand you over to be tortured and will put you to death, and you will be hated by all nations because of my name. 10Then many will fall away, and they will betray one another and hate one another. 11And many false prophets will arise and lead many astray. 12And because of the increase of lawlessness, the love of many will grow cold. 13But the one who endures to the end will be saved. 14And this good news of the kingdom will be proclaimed throughout the world, as a testimony to all the nations; and then the end will come.
Evening Psalm 26
1 Vindicate me, O LORD,
for I have walked in my integrity,
and I have trusted in the LORD without wavering.
2 Prove me, O LORD, and try me;
test my heart and mind.
3 For your steadfast love is before my eyes,
and I walk in faithfulness to you.
4 I do not sit with the worthless,
nor do I consort with hypocrites;
5 I hate the company of evildoers,
and will not sit with the wicked.
6 I wash my hands in innocence,
and go around your altar, O LORD,
7 singing aloud a song of thanksgiving,
and telling all your wondrous deeds.
8 O LORD, I love the house in which you dwell,
and the place where your glory abides.
9 Do not sweep me away with sinners,
nor my life with the bloodthirsty,
10 those in whose hands are evil devices,
and whose right hands are full of bribes.
11 But as for me, I walk in my integrity;
redeem me, and be gracious to me.
12 My foot stands on level ground;
in the great congregation I will bless the LORD.
Evening Psalm 130
1 Out of the depths I cry to you, O LORD.
2 Lord, hear my voice!
Let your ears be attentive
to the voice of my supplications!
3 If you, O LORD, should mark iniquities,
Lord, who could stand?
4 But there is forgiveness with you,
so that you may be revered.
5 I wait for the LORD, my soul waits,
and in his word I hope;
6 my soul waits for the Lord
more than those who watch for the morning,
more than those who watch for the morning.
7 O Israel, hope in the LORD!
For with the LORD there is steadfast love,
and with him is great power to redeem.
8 It is he who will redeem Israel
from all its iniquities.


text:
Since 1979 + EveryWhere
There are no items in your shopping cart.
Works faster and stays in air longer. Half the size of ordinary refills, but twice the odor-fighting power. For use in TimeMist® Micro Ultra Metered Aerosol, TimeMist® Classic Series and TimeMist® Settings Micro dispensers, all sold separately. Refill is perfectly sized for pockets, purses, desktops; 15- to 45-day refill (depending on spray interval setting).
Scent: Mango; Physical Form: Liquid; Application: Odor Control; Capacity (Volume): 3 oz.


text:
Laws, Regulations and Annotations
Business Taxes Law Guide – Revision 2024
Diesel Fuel Tax Annotations
Exempt Entities
U.S. Postal Service. The U.S. Postal Service is an unincorporated instrumentality of the federal government and as such is exempt from the Diesel Fuel Tax. A company which leases trucks to the U.S. Postal Service may apply for a refund of tax paid on diesel fuel used by such trucks where the fuel cost is included in the lease agreement. 3/07/96.


text:
I'm about to re-launch a uk based community interest company website which has the same link structure for each of 10 different top level domains.
There are presently no international websites, but there may be in the future.
For simplicity's sake I intend to nominate a single primary domain (.org.uk) and then use htaccess to redirect incoming traffic from alternative TLD's back to the primary domain.
Is this best practice in terms of efficiency and SEO?
Would there be any benefit to using .com or .co.uk as the primary domain.


text:
United Visual Products' Enclosed Cork Bulletin Board with Header allows you to post messages and awards in a professional, eye-catching display. A fluorescent light fixture at the top of the unit brightens your board. This bulletin board features a stylish white header bar with your message - up to 3" high - neatly showcased. The natural cork surface is self healing, so it won't show pin holes. Full-length piano door hinges stay securely fastened to the satin anodized aluminum frame. The acrylic window offers a clear view inside and won't shatter if broken. This United Visual Products' 48" wide by 48" high Illuminated Enclosed Cork Board with Header and One Door comes backed by a one-year warranty. Note: A professional electrician is required for installation.
Key Features
- Satin anodized aluminum frame
- Stylish header features your message
- Illuminated from lights at the top
- Self-sealing natural cork interior
- Acrylic window
- Lockable door is mounted on full-length piano hinges (two keys included)
- Backed by a one-year warranty
- Tack Surface: Natural cork
- Frame Material: Aluminum
- Doors: 1
- Use: Indoor
- Frame Width: 1"
- Exterior Depth: 3 1/8"
- Interior Depth: 1 5/8"
- Overall Width: 48"
- Height: 48"
- Estimated Lead Time: Ships within 4 - 5 business days
- Shipping Method: Freight
- Weight: 48.00 pounds


text:
Uber settles Waymo theft allegations with $245 million payout
By Michael Liedtke And Tom Krisher, THE ASSOCIATED PRESS
General Automotive Uber WaymoWaymo alleged that former Google engineer Levandowski heisted its technology and took it to Uber via a startup he founded and which Uber purchased a few months later for $680 million.
SAN FRANCISCO — Uber is paying $245 million to Google's self-driving car spinoff to end a legal brawl that aired out allegations of a sinister scheme that tore apart the once-friendly companies.
The surprise settlement announced Friday came as lawyers for Uber and Waymo, a company hatched from Google, prepared to wrap up the first week of a trial that had attracted international attention.
Waymo filed its lawsuit nearly a year ago , adding to Uber's woes with allegations of a bold high-tech heist orchestrated by its former CEO, Travis Kalanick, and a former Google engineer. That engineer, Anthony Levandowski, subsequently went to work for Uber, and was later fired when he declined to answer questions about the theft charges, citing his Fifth Amendment right against self-incrimination.
Uber and its ride-hailing service had already been tarnished by the company's acknowledgement of rampant sexual harassment within its ranks, a yearlong coverup of a major computer break-in, and the use of duplicitous software to thwart government regulators.
As with most settlements, the truce required some compromise by both sides. Uber had initially offered to settle the case for $490 million just before the start of the trial Monday, but that agreement didn't provide Waymo with enough assurances that its technology wouldn't be improperly used, according to two people familiar with the thinking of both parties in the lawsuit. The people asked not to be identified because the settlement talks were confidential.
Not long after Thursday's trial proceedings ended, the top lawyers from both companies, Uber's Tony West and Waymo's Kevin Vosen, met to hammer out an agreement. The resulting compromise cut Uber's payment in half, but provided Waymo with the guarantees that it wanted to prevent its technology from being used in Uber's autonomous cars.
The payment, to be made in Uber's stock, is a fraction of the nearly $2 billion in damages that a Waymo expert had estimated Uber's alleged theft had caused. But U.S. District Judge William Alsup had refused to allow Waymo to use that figure in the trial.
"This has the look of two companies trying to snatch victory from the jaws of defeat," said Dan Handman, a Los Angeles lawyer specializing in trade secrets for the firm Hirschfeld Kraemer. "You try to structure a settlement so both sides can spin it as a win-win situation."
A settlement in the middle of a trial is highly unusual, but both companies had motives for doing so in this case.
Kalanick, a polarizing figure who resigned as Uber's CEO last June, had already spent part of two days on the stand reviewing old texts between him and Levandowski indicating that they were willing to go to any lengths to catch up with a self-driving car project that Google started in 2009. The texts included snippets such as "second place is first looser (sic), "burn the village," and a link to a video clip from the 1987 film "Wall Street" featuring a character hailing the virtues of unbridled greed.
Levandowski was also set to take the stand Monday, when he was expected once again to repeatedly take the Fifth, a move that Uber's lawyers feared would prejudice the 10-person jury against the company. "The optics of someone not wanting to incriminate himself in front of a jury in a civil case are terrible," Handman said.
Uber's settlement won't necessarily help Levandowski, though. The U.S. Justice Department opened a criminal probe at the prodding of Alsup, although it hasn't publicly identified the targets of that investigation.
Waymo alleged that Levandowski heisted its technology and took it to Uber via a startup he founded and which Uber purchased a few months later for $680 million. Uber denied using any Google technology to build a fleet of self-driving cars.
Including the settlement, the cost of that Otto deal is now nearly $1 billion, without factoring in Uber's legal bills in the case. It's a deal that one of Uber's own attorneys acknowledged the company now regrets.
"Knowing everything we know, Uber regrets ever bringing Anthony Levandowski on board," Uber lawyer William Carmody told the jury in his opening statement. "And the reason they do so is because for all his time at Uber, all Uber has to show for Anthony Levandowski is this lawsuit."
But the settlement at least removes a dark cloud that Uber didn't want looming when it offers its stock to the public — something its current CEO, Dara Khosrowshahi, plans to pursue next year. The settlement also covers more than 100 other trade secrets that Waymo alleges Levandowski stole. Waymo could have filed additional claims against Uber in the months and years ahead, but that's no longer a possibility unless Waymo finds additional evidence of Uber using its technology.
"If you are an Uber investor, you should be pleased with the outcome, given what could have happened if they had lost," said Rohit Kulkarni, managing director of SharesPost, a research group focused on privately held companies.
For Waymo, the settlement protects the technology that has vaulted it into the early lead in the self-driving car market and provides a measure of personal vindication for Google co-founder Larry Page, who is now CEO of Alphabet Inc., the parent of both Waymo and Google.
According to Kalanick's testimony, Page had become "very upset" in 2015 when he learned Uber had hired robotics engineers from Carnegie-Mellon University in Pittsburgh for its own self-driving car division. "He sort of was a little angsty and said, 'Why are you doing my thing?'" Kalanick recalled.
The settlement also means Page won't have to appear on the stand himself.
Alphabet had another reason to settle. It was an early investor in Uber and, although it sold some of its stock late last year, it still holds a significant stake in Uber. The settlement gives Alphabet an additional 0.34 per cent of Uber's outstanding stock.
"We are committed to working with Uber to make sure that each company develops its own technology," Waymo said in its statement.


text:
What says "patriotism" more than a long Fourth of July weekend in the Hamptons? For luxury seeking beachgoers, not much. Unless, of course, that beach trip comes with a private driver and a helicopter transfer.
Uber is launching a special UberCHOPPERS service exclusively on July 3, offering SUV service (for you and up to four friends) for transport to the helipad, to East Hampton, and on to your final destination. The cost? A cool $3,000 for the entire deal, all pre-paid via credit card, tips included. Considering a standard trip is around $3,500 on other charters, not including rides to and from the helipad, this is a good deal.
Additionally, Uber is running its network of cars all the way from Southampton to Montauk this July Fourth and during weekends this summer.