Backbone JS

// [Link] 1.1.0

// (c) 2010-2011 Jeremy Ashkenas, DocumentCloud Inc.

// (c) 2011-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters &
Editors
// Backbone may be freely distributed under the MIT license.
// For all details and documentation:
// [Link]

(function(){

// Initial Setup
// -------------

// Save a reference to the global object (`window` in the browser, `exports`

// on the server).
var root = this;

// Save the previous value of the `Backbone` variable, so that it can be

// restored later on, if `noConflict` is used.
var previousBackbone = [Link];

// Create local references to array methods we'll want to use later.

var array = [];
var push = [Link];
var slice = [Link];
var splice = [Link];

// The top-level namespace. All public Backbone classes and modules will
// be attached to this. Exported for both the browser and the server.
var Backbone;
if (typeof exports !== 'undefined') {
Backbone = exports;
} else {
Backbone = [Link] = {};
}

// Current version of the library. Keep in sync with `[Link]`.

[Link] = '1.1.0';

// Require Underscore, if we're on the server, and it's not already present.
var _ = root._;
if (!_ && (typeof require !== 'undefined')) _ = require('underscore');

// For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns

// the `$` variable.
Backbone.$ = [Link] || [Link] || [Link] || root.$;

// Runs [Link] in *noConflict* mode, returning the `Backbone` variable

// to its previous owner. Returns a reference to this Backbone object.
[Link] = function() {
[Link] = previousBackbone;
return this;
};

// Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option

// will fake `"PATCH"`, `"PUT"` and `"DELETE"` requests via the `_method` parameter
and
// set a `X-Http-Method-Override` header.
[Link] = false;
 // Turn on `emulateJSON` to support legacy servers that can't deal with direct
// `application/json` requests ... will encode the body as
// `application/x-www-form-urlencoded` instead and will send the model in a
// form param named `model`.
[Link] = false;

// [Link]
// ---------------

// A module that can be mixed in to *any object* in order to provide it with

// custom events. You may bind with `on` or remove with `off` callback
// functions to an event; `trigger`-ing an event fires all callbacks in
// succession.
//
// var object = {};
// _.extend(object, [Link]);
// [Link]('expand', function(){ alert('expanded'); });
// [Link]('expand');
//
var Events = [Link] = {

// Bind an event to a `callback` function. Passing `"all"` will bind

// the callback to all events fired.
on: function(name, callback, context) {
if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
this._events || (this._events = {});
var events = this._events[name] || (this._events[name] = []);
[Link]({callback: callback, context: context, ctx: context || this});
return this;
},

// Bind an event to only be triggered a single time. After the first time
// the callback is invoked, it will be removed.
once: function(name, callback, context) {
if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return
this;
var self = this;
var once = _.once(function() {
[Link](name, once);
[Link](this, arguments);
});
once._callback = callback;
return [Link](name, once, context);
},

// Remove one or many callbacks. If `context` is null, removes all

// callbacks with that function. If `callback` is null, removes all
// callbacks for the event. If `name` is null, removes all bound
// callbacks for all events.
off: function(name, callback, context) {
var retain, ev, events, names, i, l, j, k;
if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return
this;
if (!name && !callback && !context) {
this._events = {};
return this;
}
names = name ? [name] : _.keys(this._events);
for (i = 0, l = [Link]; i < l; i++) {
name = names[i];
if (events = this._events[name]) {
this._events[name] = retain = [];
 if (callback || context) {
for (j = 0, k = [Link]; j < k; j++) {
ev = events[j];
if ((callback && callback !== [Link] && callback !==
[Link]._callback) ||
(context && context !== [Link])) {
[Link](ev);
}
}
}
if (![Link]) delete this._events[name];
}
}

return this;
},

// Trigger one or many events, firing all bound callbacks. Callbacks are
// passed the same arguments as `trigger` is, apart from the event name
// (unless you're listening on `"all"`, which will cause your callback to
// receive the true name of the event as the first argument).
trigger: function(name) {
if (!this._events) return this;
var args = [Link](arguments, 1);
if (!eventsApi(this, 'trigger', name, args)) return this;
var events = this._events[name];
var allEvents = this._events.all;
if (events) triggerEvents(events, args);
if (allEvents) triggerEvents(allEvents, arguments);
return this;
},

// Tell this object to stop listening to either specific events ... or

// to every object it's currently listening to.
stopListening: function(obj, name, callback) {
var listeningTo = this._listeningTo;
if (!listeningTo) return this;
var remove = !name && !callback;
if (!callback && typeof name === 'object') callback = this;
if (obj) (listeningTo = {})[obj._listenId] = obj;
for (var id in listeningTo) {
obj = listeningTo[id];
[Link](name, callback, this);
if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];
}
return this;
}

};

// Regular expression used to split event strings.

var eventSplitter = /\s+/;

// Implement fancy features of the Events API such as multiple event

// names `"change blur"` and jQuery-style event maps `{change: action}`
// in terms of the existing API.
var eventsApi = function(obj, action, name, rest) {
if (!name) return true;

// Handle event maps.

if (typeof name === 'object') {
for (var key in name) {
obj[action].apply(obj, [key, name[key]].concat(rest));
 }
return false;
}

// Handle space separated event names.

if ([Link](name)) {
var names = [Link](eventSplitter);
for (var i = 0, l = [Link]; i < l; i++) {
obj[action].apply(obj, [names[i]].concat(rest));
}
return false;
}

return true;
};

// A difficult-to-believe, but optimized internal dispatch function for

// triggering events. Tries to keep the usual cases speedy (most internal
// Backbone events have 3 arguments).
var triggerEvents = function(events, args) {
var ev, i = -1, l = [Link], a1 = args[0], a2 = args[1], a3 = args[2];
switch ([Link]) {
case 0: while (++i < l) (ev = events[i]).[Link]([Link]); return;
case 1: while (++i < l) (ev = events[i]).[Link]([Link], a1); return;
case 2: while (++i < l) (ev = events[i]).[Link]([Link], a1, a2); return;
case 3: while (++i < l) (ev = events[i]).[Link]([Link], a1, a2, a3);
return;
default: while (++i < l) (ev = events[i]).[Link]([Link], args);
}
};

var listenMethods = {listenTo: 'on', listenToOnce: 'once'};

// Inversion-of-control versions of `on` and `once`. Tell *this* object to

// listen to an event in another object ... keeping track of what it's
// listening to.
_.each(listenMethods, function(implementation, method) {
Events[method] = function(obj, name, callback) {
var listeningTo = this._listeningTo || (this._listeningTo = {});
var id = obj._listenId || (obj._listenId = _.uniqueId('l'));
listeningTo[id] = obj;
if (!callback && typeof name === 'object') callback = this;
obj[implementation](name, callback, this);
return this;
};
});

// Aliases for backwards compatibility.

[Link] = [Link];
[Link] = [Link];

// Allow the `Backbone` object to serve as a global event bus, for folks who
// want global "pubsub" in a convenient place.
_.extend(Backbone, Events);

// [Link]
// --------------

// Backbone **Models** are the basic data object in the framework --

// frequently representing a row in a table in a database on your server.
// A discrete chunk of data and a bunch of useful, related methods for
// performing computations and transformations on that data.
// Create a new model with the specified attributes. A client id (`cid`)
// is automatically generated and assigned for you.
var Model = [Link] = function(attributes, options) {
var attrs = attributes || {};
options || (options = {});
[Link] = _.uniqueId('c');
[Link] = {};
if ([Link]) [Link] = [Link];
if ([Link]) attrs = [Link](attrs, options) || {};
attrs = _.defaults({}, attrs, _.result(this, 'defaults'));
[Link](attrs, options);
[Link] = {};
[Link](this, arguments);
};

// Attach all inheritable methods to the Model prototype.

_.extend([Link], Events, {

// A hash of attributes whose current and previous value differ.

changed: null,

// The value returned during the last failed validation.

validationError: null,

// The default name for the JSON `id` attribute is `"id"`. MongoDB and
// CouchDB users may want to set this to `"_id"`.
idAttribute: 'id',

// Initialize is an empty function by default. Override it with your own

// initialization logic.
initialize: function(){},

// Return a copy of the model's `attributes` object.

toJSON: function(options) {
return _.clone([Link]);
},

// Proxy `[Link]` by default -- but override this if you need

// custom syncing semantics for *this* particular model.
sync: function() {
return [Link](this, arguments);
},

// Get the value of an attribute.

get: function(attr) {
return [Link][attr];
},

// Get the HTML-escaped value of an attribute.

escape: function(attr) {
return _.escape([Link](attr));
},

// Returns `true` if the attribute contains a value that is not null

// or undefined.
has: function(attr) {
return [Link](attr) != null;
},

// Set a hash of model attributes on the object, firing `"change"`. This is

// the core primitive operation of a model, updating the data and notifying
// anyone who needs to know about the change in state. The heart of the beast.
set: function(key, val, options) {
var attr, attrs, unset, changes, silent, changing, prev, current;
if (key == null) return this;

// Handle both `"key", value` and `{key: value}` -style arguments.

if (typeof key === 'object') {
attrs = key;
options = val;
} else {
(attrs = {})[key] = val;
}

options || (options = {});

// Run validation.
if (!this._validate(attrs, options)) return false;

// Extract attributes and options.

unset = [Link];
silent = [Link];
changes = [];
changing = this._changing;
this._changing = true;

if (!changing) {
this._previousAttributes = _.clone([Link]);
[Link] = {};
}
current = [Link], prev = this._previousAttributes;

// Check for changes of `id`.

if ([Link] in attrs) [Link] = attrs[[Link]];

// For each `set` attribute, update or delete the current value.

for (attr in attrs) {
val = attrs[attr];
if (!_.isEqual(current[attr], val)) [Link](attr);
if (!_.isEqual(prev[attr], val)) {
[Link][attr] = val;
} else {
delete [Link][attr];
}
unset ? delete current[attr] : current[attr] = val;
}

// Trigger all relevant attribute changes.

if (!silent) {
if ([Link]) this._pending = true;
for (var i = 0, l = [Link]; i < l; i++) {
[Link]('change:' + changes[i], this, current[changes[i]], options);
}
}

// You might be wondering why there's a `while` loop here. Changes can
// be recursively nested within `"change"` events.
if (changing) return this;
if (!silent) {
while (this._pending) {
this._pending = false;
[Link]('change', this, options);
}
}
this._pending = false;
this._changing = false;
 return this;
},

// Remove an attribute from the model, firing `"change"`. `unset` is a noop

// if the attribute doesn't exist.
unset: function(attr, options) {
return [Link](attr, void 0, _.extend({}, options, {unset: true}));
},

// Clear all attributes on the model, firing `"change"`.

clear: function(options) {
var attrs = {};
for (var key in [Link]) attrs[key] = void 0;
return [Link](attrs, _.extend({}, options, {unset: true}));
},

// Determine if the model has changed since the last `"change"` event.
// If you specify an attribute name, determine if that attribute has changed.
hasChanged: function(attr) {
if (attr == null) return !_.isEmpty([Link]);
return _.has([Link], attr);
},

// Return an object containing all the attributes that have changed, or

// false if there are no changed attributes. Useful for determining what
// parts of a view need to be updated and/or what attributes need to be
// persisted to the server. Unset attributes will be set to undefined.
// You can also pass an attributes object to diff against the model,
// determining if there *would be* a change.
changedAttributes: function(diff) {
if (!diff) return [Link]() ? _.clone([Link]) : false;
var val, changed = false;
var old = this._changing ? this._previousAttributes : [Link];
for (var attr in diff) {
if (_.isEqual(old[attr], (val = diff[attr]))) continue;
(changed || (changed = {}))[attr] = val;
}
return changed;
},

// Get the previous value of an attribute, recorded at the time the last
// `"change"` event was fired.
previous: function(attr) {
if (attr == null || !this._previousAttributes) return null;
return this._previousAttributes[attr];
},

// Get all of the attributes of the model at the time of the previous
// `"change"` event.
previousAttributes: function() {
return _.clone(this._previousAttributes);
},

// Fetch the model from the server. If the server's representation of the
// model differs from its current attributes, they will be overridden,
// triggering a `"change"` event.
fetch: function(options) {
options = options ? _.clone(options) : {};
if ([Link] === void 0) [Link] = true;
var model = this;
var success = [Link];
[Link] = function(resp) {
if (, options)) return false;
 if (success) success(model, resp, options);
[Link]('sync', model, resp, options);
};
wrapError(this, options);
return [Link]('read', this, options);
},

// Set a hash of model attributes, and sync the model to the server.
// If the server returns an attributes hash that differs, the model's
// state will be `set` again.
save: function(key, val, options) {
var attrs, method, xhr, attributes = [Link];

// Handle both `"key", value` and `{key: value}` -style arguments.

if (key == null || typeof key === 'object') {
attrs = key;
options = val;
} else {
(attrs = {})[key] = val;
}

options = _.extend({validate: true}, options);

// If we're not waiting and attributes exist, save acts as

// `set(attr).save(null, opts)` with validation. Otherwise, check if
// the model will be valid when the attributes, if any, are set.
if (attrs && ![Link]) {
if () return false;
} else {
if (!this._validate(attrs, options)) return false;
}

// Set temporary attributes if `{wait: true}`.

if (attrs && [Link]) {
[Link] = _.extend({}, attributes, attrs);
}

// After a successful server-side save, the client is (optionally)

// updated with the server-side state.
if ([Link] === void 0) [Link] = true;
var model = this;
var success = [Link];
[Link] = function(resp) {
// Ensure attributes are restored during synchronous saves.
[Link] = attributes;
var serverAttrs = [Link](resp, options);
if ([Link]) serverAttrs = _.extend(attrs || {}, serverAttrs);
if (_.isObject(serverAttrs) && ) {
return false;
}
if (success) success(model, resp, options);
[Link]('sync', model, resp, options);
};
wrapError(this, options);

method = [Link]() ? 'create' : ([Link] ? 'patch' : 'update');

if (method === 'patch') [Link] = attrs;
xhr = [Link](method, this, options);

// Restore attributes.
if (attrs && [Link]) [Link] = attributes;

return xhr;
 },

// Destroy this model on the server if it was already persisted.

// Optimistically removes the model from its collection, if it has one.
// If `wait: true` is passed, waits for the server to respond before removal.
destroy: function(options) {
options = options ? _.clone(options) : {};
var model = this;
var success = [Link];

var destroy = function() {

[Link]('destroy', model, [Link], options);
};

[Link] = function(resp) {
if ([Link] || [Link]()) destroy();
if (success) success(model, resp, options);
if (![Link]()) [Link]('sync', model, resp, options);
};

if ([Link]()) {
[Link]();
return false;
}
wrapError(this, options);

var xhr = [Link]('delete', this, options);

if (![Link]) destroy();
return xhr;
},

// Default URL for the model's representation on the server -- if you're

// using Backbone's restful methods, override this to change the endpoint
// that will be called.
url: function() {
var base = _.result(this, 'urlRoot') || _.result([Link], 'url') ||
urlError();
if ([Link]()) return base;
return base + ([Link]([Link] - 1) === '/' ? '' : '/') +
encodeURIComponent([Link]);
},

// **parse** converts a response into the hash of attributes to be `set` on

// the model. The default implementation is just to pass the response along.
parse: function(resp, options) {
return resp;
},

// Create a new model with identical attributes to this one.

clone: function() {
return new [Link]([Link]);
},

// A model is new if it has never been saved to the server, and lacks an id.
isNew: function() {
return [Link] == null;
},

// Check if the model is currently in a valid state.

isValid: function(options) {
return this._validate({}, _.extend(options || {}, { validate: true }));
},
 // Run validation against the next complete set of model attributes,
// returning `true` if all is well. Otherwise, fire an `"invalid"` event.
_validate: function(attrs, options) {
if (![Link] || ![Link]) return true;
attrs = _.extend({}, [Link], attrs);
var error = [Link] = [Link](attrs, options) || null;
if (!error) return true;
[Link]('invalid', this, error, _.extend(options, {validationError:
error}));
return false;
}

});

// Underscore methods that we want to implement on the Model.

var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];

// Mix in each Underscore method as a proxy to `Model#attributes`.

_.each(modelMethods, function(method) {
[Link][method] = function() {
var args = [Link](arguments);
[Link]([Link]);
return _[method].apply(_, args);
};
});

// [Link]
// -------------------

// If models tend to represent a single row of data, a Backbone Collection is

// more analagous to a table full of data ... or a small slice or page of that
// table, or a collection of rows that belong together for a particular reason
// -- all of the messages in this particular folder, all of the documents
// belonging to this particular author, and so on. Collections maintain
// indexes of their models, both in order, and for lookup by `id`.

// Create a new **Collection**, perhaps to contain a specific type of `model`.

// If a `comparator` is specified, the Collection will maintain
// its models in sort order, as they're added and removed.
var Collection = [Link] = function(models, options) {
options || (options = {});
if ([Link]) [Link] = [Link];
if ([Link] !== void 0) [Link] = [Link];
this._reset();
[Link](this, arguments);
if (models) [Link](models, _.extend({silent: true}, options));
};

// Default options for `Collection#set`.

var setOptions = {add: true, remove: true, merge: true};
var addOptions = {add: true, remove: false};

// Define the Collection's inheritable methods.

_.extend([Link], Events, {

// The default model for a collection is just a **[Link]**.

// This should be overridden in most cases.
model: Model,

// Initialize is an empty function by default. Override it with your own

// initialization logic.
initialize: function(){},
// The JSON representation of a Collection is an array of the
// models' attributes.
toJSON: function(options) {
return [Link](function(model){ return [Link](options); });
},

// Proxy `[Link]` by default.

sync: function() {
return [Link](this, arguments);
},

// Add a model, or list of models to the set.

add: function(models, options) {
return [Link](models, _.extend({merge: false}, options, addOptions));
},

// Remove a model, or a list of models from the set.

remove: function(models, options) {
var singular = !_.isArray(models);
models = singular ? [models] : _.clone(models);
options || (options = {});
var i, l, index, model;
for (i = 0, l = [Link]; i < l; i++) {
model = models[i] = [Link](models[i]);
if (!model) continue;
delete this._byId[[Link]];
delete this._byId[[Link]];
index = [Link](model);
[Link](index, 1);
[Link]--;
if (![Link]) {
[Link] = index;
[Link]('remove', model, this, options);
}
this._removeReference(model);
}
return singular ? models[0] : models;
},

// Update a collection by `set`-ing a new list of models, adding new ones,

// removing models that are no longer present, and merging models that
// already exist in the collection, as necessary. Similar to **Model#set**,
// the core operation for updating the data contained by the collection.
set: function(models, options) {
options = _.defaults({}, options, setOptions);
if ([Link]) models = [Link](models, options);
var singular = !_.isArray(models);
models = singular ? (models ? [models] : []) : _.clone(models);
var i, l, id, model, attrs, existing, sort;
var at = [Link];
var targetModel = [Link];
var sortable = [Link] && (at == null) && [Link] !== false;
var sortAttr = _.isString([Link]) ? [Link] : null;
var toAdd = [], toRemove = [], modelMap = {};
var add = [Link], merge = [Link], remove = [Link];
var order = !sortable && add && remove ? [] : false;

// Turn bare objects into model references, and prevent invalid models
// from being added.
for (i = 0, l = [Link]; i < l; i++) {
attrs = models[i];
if (attrs instanceof Model) {
id = model = attrs;
 } else {
id = attrs[[Link]];
}

// If a duplicate is found, prevent it from being added and

// optionally merge it into the existing model.
if (existing = [Link](id)) {
if (remove) modelMap[[Link]] = true;
if (merge) {
attrs = attrs === model ? [Link] : attrs;
if ([Link]) attrs = [Link](attrs, options);
[Link](attrs, options);
if (sortable && !sort && [Link](sortAttr)) sort = true;
}
models[i] = existing;

// If this is a new, valid model, push it to the `toAdd` list.

} else if (add) {
model = models[i] = this._prepareModel(attrs, options);
if (!model) continue;
[Link](model);

// Listen to added models' events, and index models for lookup by

// `id` and by `cid`.
[Link]('all', this._onModelEvent, this);
this._byId[[Link]] = model;
if ([Link] != null) this._byId[[Link]] = model;
}
if (order) [Link](existing || model);
}

// Remove nonexistent models if appropriate.

if (remove) {
for (i = 0, l = [Link]; i < l; ++i) {
if (!modelMap[(model = [Link][i]).cid]) [Link](model);
}
if ([Link]) [Link](toRemove, options);
}

// See if sorting is needed, update `length` and splice in new models.

if ([Link] || (order && [Link])) {
if (sortable) sort = true;
[Link] += [Link];
if (at != null) {
for (i = 0, l = [Link]; i < l; i++) {
[Link](at + i, 0, toAdd[i]);
}
} else {
if (order) [Link] = 0;
var orderedModels = order || toAdd;
for (i = 0, l = [Link]; i < l; i++) {
[Link](orderedModels[i]);
}
}
}

// Silently sort the collection if appropriate.

if (sort) [Link]({silent: true});

// Unless silenced, it's time to fire all appropriate add/sort events.

if (![Link]) {
for (i = 0, l = [Link]; i < l; i++) {
(model = toAdd[i]).trigger('add', model, this, options);
 }
if (sort || (order && [Link])) [Link]('sort', this, options);
}

// Return the added (or merged) model (or models).

return singular ? models[0] : models;
},

// When you have more items than you want to add or remove individually,
// you can reset the entire set with a new list of models, without firing
// any granular `add` or `remove` events. Fires `reset` when finished.
// Useful for bulk operations and optimizations.
reset: function(models, options) {
options || (options = {});
for (var i = 0, l = [Link]; i < l; i++) {
this._removeReference([Link][i]);
}
[Link] = [Link];
this._reset();
models = [Link](models, _.extend({silent: true}, options));
if (![Link]) [Link]('reset', this, options);
return models;
},

// Add a model to the end of the collection.

push: function(model, options) {
return [Link](model, _.extend({at: [Link]}, options));
},

// Remove a model from the end of the collection.

pop: function(options) {
var model = [Link]([Link] - 1);
[Link](model, options);
return model;
},

// Add a model to the beginning of the collection.

unshift: function(model, options) {
return [Link](model, _.extend({at: 0}, options));
},

// Remove a model from the beginning of the collection.

shift: function(options) {
var model = [Link](0);
[Link](model, options);
return model;
},

// Slice out a sub-array of models from the collection.

slice: function() {
return [Link]([Link], arguments);
},

// Get a model from the set by id.

get: function(obj) {
if (obj == null) return void 0;
return this._byId[[Link]] || this._byId[[Link]] || this._byId[obj];
},

// Get the model at the given index.

at: function(index) {
return [Link][index];
},
// Return models with matching attributes. Useful for simple cases of
// `filter`.
where: function(attrs, first) {
if (_.isEmpty(attrs)) return first ? void 0 : [];
return this[first ? 'find' : 'filter'](function(model) {
for (var key in attrs) {
if (attrs[key] !== [Link](key)) return false;
}
return true;
});
},

// Return the first model with matching attributes. Useful for simple cases
// of `find`.
findWhere: function(attrs) {
return [Link](attrs, true);
},

// Force the collection to re-sort itself. You don't need to call this under
// normal circumstances, as the set will maintain sort order as each item
// is added.
sort: function(options) {
if (![Link]) throw new Error('Cannot sort a set without a comparator');
options || (options = {});

// Run sort based on type of `comparator`.

if (_.isString([Link]) || [Link] === 1) {
[Link] = [Link]([Link], this);
} else {
[Link](_.bind([Link], this));
}

if (![Link]) [Link]('sort', this, options);

return this;
},

// Pluck an attribute from each model in the collection.

pluck: function(attr) {
return _.invoke([Link], 'get', attr);
},

// Fetch the default set of models for this collection, resetting the
// collection when they arrive. If `reset: true` is passed, the response
// data will be passed through the `reset` method instead of `set`.
fetch: function(options) {
options = options ? _.clone(options) : {};
if ([Link] === void 0) [Link] = true;
var success = [Link];
var collection = this;
[Link] = function(resp) {
var method = [Link] ? 'reset' : 'set';
collection[method](resp, options);
if (success) success(collection, resp, options);
[Link]('sync', collection, resp, options);
};
wrapError(this, options);
return [Link]('read', this, options);
},

// Create a new instance of a model in this collection. Add the model to the
// collection immediately, unless `wait: true` is passed, in which case we
// wait for the server to agree.
create: function(model, options) {
options = options ? _.clone(options) : {};
if (!(model = this._prepareModel(model, options))) return false;
if (![Link]) [Link](model, options);
var collection = this;
var success = [Link];
[Link] = function(model, resp, options) {
if ([Link]) [Link](model, options);
if (success) success(model, resp, options);
};
[Link](null, options);
return model;
},

// **parse** converts a response into a list of models to be added to the

// collection. The default implementation is just to pass it through.
parse: function(resp, options) {
return resp;
},

// Create a new collection with an identical list of models as this one.

clone: function() {
return new [Link]([Link]);
},

// Private method to reset all internal state. Called when the collection
// is first initialized or reset.
_reset: function() {
[Link] = 0;
[Link] = [];
this._byId = {};
},

// Prepare a hash of attributes (or other model) to be added to this

// collection.
_prepareModel: function(attrs, options) {
if (attrs instanceof Model) {
if (![Link]) [Link] = this;
return attrs;
}
options = options ? _.clone(options) : {};
[Link] = this;
var model = new [Link](attrs, options);
if (![Link]) return model;
[Link]('invalid', this, [Link], options);
return false;
},

// Internal method to sever a model's ties to a collection.

_removeReference: function(model) {
if (this === [Link]) delete [Link];
[Link]('all', this._onModelEvent, this);
},

// Internal method called every time a model in the set fires an event.
// Sets need to update their indexes when models change ids. All other
// events simply proxy through. "add" and "remove" events that originate
// in other collections are ignored.
_onModelEvent: function(event, model, collection, options) {
if ((event === 'add' || event === 'remove') && collection !== this) return;
if (event === 'destroy') [Link](model, options);
if (model && event === 'change:' + [Link]) {
delete this._byId[[Link]([Link])];
 if ([Link] != null) this._byId[[Link]] = model;
}
[Link](this, arguments);
}

});

// Underscore methods that we want to implement on the Collection.

// 90% of the core usefulness of Backbone Collections is actually implemented
// right here:
var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',
'lastIndexOf', 'isEmpty', 'chain'];

// Mix in each Underscore method as a proxy to `Collection#models`.

_.each(methods, function(method) {
[Link][method] = function() {
var args = [Link](arguments);
[Link]([Link]);
return _[method].apply(_, args);
};
});

// Underscore methods that take a property name as an argument.

var attributeMethods = ['groupBy', 'countBy', 'sortBy'];

// Use attributes instead of properties.

_.each(attributeMethods, function(method) {
[Link][method] = function(value, context) {
var iterator = _.isFunction(value) ? value : function(model) {
return [Link](value);
};
return _[method]([Link], iterator, context);
};
});

// [Link]
// -------------

// Backbone Views are almost more convention than they are actual code. A View
// is simply a JavaScript object that represents a logical chunk of UI in the
// DOM. This might be a single item, an entire list, a sidebar or panel, or
// even the surrounding frame which wraps your whole app. Defining a chunk of
// UI as a **View** allows you to define your DOM events declaratively, without
// having to worry about render order ... and makes it easy for the view to
// react to specific changes in the state of your models.

// Creating a [Link] creates its initial element outside of the DOM,

// if an existing element is not provided...
var View = [Link] = function(options) {
[Link] = _.uniqueId('view');
options || (options = {});
_.extend(this, _.pick(options, viewOptions));
this._ensureElement();
[Link](this, arguments);
[Link]();
};

// Cached regex to split keys for `delegate`.

var delegateEventSplitter = /^(\S+)\s*(.*)$/;
 // List of view options to be merged as properties.
var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className',
'tagName', 'events'];

// Set up all inheritable **[Link]** properties and methods.

_.extend([Link], Events, {

// The default `tagName` of a View's element is `"div"`.

tagName: 'div',

// jQuery delegate for element lookup, scoped to DOM elements within the
// current view. This should be preferred to global lookups where possible.
$: function(selector) {
return this.$[Link](selector);
},

// Initialize is an empty function by default. Override it with your own

// initialization logic.
initialize: function(){},

// **render** is the core function that your view should override, in order
// to populate its element (`[Link]`), with the appropriate HTML. The
// convention is for **render** to always return `this`.
render: function() {
return this;
},

// Remove this view by taking the element out of the DOM, and removing any
// applicable [Link] listeners.
remove: function() {
this.$[Link]();
[Link]();
return this;
},

// Change the view's element (`[Link]` property), including event

// re-delegation.
setElement: function(element, delegate) {
if (this.$el) [Link]();
this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
[Link] = this.$el[0];
if (delegate !== false) [Link]();
return this;
},

// Set callbacks, where `[Link]` is a hash of

//
// *{"event selector": "callback"}*
//
// {
// 'mousedown .title': 'edit',
// 'click .button': 'save',
// 'click .open': function(e) { ... }
// }
//
// pairs. Callbacks will be bound to the view, with `this` set properly.
// Uses event delegation for efficiency.
// Omitting the selector binds the event to `[Link]`.
// This only works for delegate-able events: not `focus`, `blur`, and
// not `change`, `submit`, and `reset` in Internet Explorer.
delegateEvents: function(events) {
if (!(events || (events = _.result(this, 'events')))) return this;
 [Link]();
for (var key in events) {
var method = events[key];
if (!_.isFunction(method)) method = this[events[key]];
if (!method) continue;

var match = [Link](delegateEventSplitter);

var eventName = match[1], selector = match[2];
method = _.bind(method, this);
eventName += '.delegateEvents' + [Link];
if (selector === '') {
this.$[Link](eventName, method);
} else {
this.$[Link](eventName, selector, method);
}
}
return this;
},

// Clears all callbacks previously bound to the view with `delegateEvents`.

// You usually don't need to use this, but may wish to if you have multiple
// Backbone views attached to the same DOM element.
undelegateEvents: function() {
this.$[Link]('.delegateEvents' + [Link]);
return this;
},

// Ensure that the View has a DOM element to render into.

// If `[Link]` is a string, pass it through `$()`, take the first
// matching element, and re-assign it to `el`. Otherwise, create
// an element from the `id`, `className` and `tagName` properties.
_ensureElement: function() {
if (![Link]) {
var attrs = _.extend({}, _.result(this, 'attributes'));
if ([Link]) [Link] = _.result(this, 'id');
if ([Link]) attrs['class'] = _.result(this, 'className');
var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
[Link]($el, false);
} else {
[Link](_.result(this, 'el'), false);
}
}

});

// [Link]
// -------------

// Override this function to change the manner in which Backbone persists

// models to the server. You will be passed the type of request, and the
// model in question. By default, makes a RESTful Ajax request
// to the model's `url()`. Some possible customizations could be:
//
// * Use `setTimeout` to batch rapid-fire updates into a single request.
// * Send up the models as XML instead of JSON.
// * Persist models via WebSockets instead of Ajax.
//
// Turn on `[Link]` in order to send `PUT` and `DELETE` requests
// as `POST`, with a `_method` parameter containing the true HTTP method,
// as well as all requests with the body as `application/x-www-form-urlencoded`
// instead of `application/json` with the model in a param named `model`.
// Useful when interfacing with server-side languages like **PHP** that make
// it difficult to read the body of `PUT` requests.
 [Link] = function(method, model, options) {
var type = methodMap[method];

// Default options, unless specified.

_.defaults(options || (options = {}), {
emulateHTTP: [Link],
emulateJSON: [Link]
});

// Default JSON-request options.

var params = {type: type, dataType: 'json'};

// Ensure that we have a URL.

if (![Link]) {
[Link] = _.result(model, 'url') || urlError();
}

// Ensure that we have the appropriate request data.

if ([Link] == null && model && (method === 'create' || method === 'update'
|| method === 'patch')) {
[Link] = 'application/json';
[Link] = [Link]([Link] || [Link](options));
}

// For older servers, emulate JSON by encoding the request into an HTML-form.
if ([Link]) {
[Link] = 'application/x-www-form-urlencoded';
[Link] = [Link] ? {model: [Link]} : {};
}

// For older servers, emulate HTTP by mimicking the HTTP method with `_method`
// And an `X-HTTP-Method-Override` header.
if ([Link] && (type === 'PUT' || type === 'DELETE' || type ===
'PATCH')) {
[Link] = 'POST';
if ([Link]) [Link]._method = type;
var beforeSend = [Link];
[Link] = function(xhr) {
[Link]('X-HTTP-Method-Override', type);
if (beforeSend) return [Link](this, arguments);
};
}

// Don't process data on a non-GET request.

if ([Link] !== 'GET' && ![Link]) {
[Link] = false;
}

// If we're sending a `PATCH` request, and we're in an old Internet Explorer

// that still has ActiveX enabled by default, override jQuery to use that
// for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.
if ([Link] === 'PATCH' && noXhrPatch) {
[Link] = function() {
return new ActiveXObject("[Link]");
};
}

// Make the request, allowing the user to override any Ajax options.
var xhr = [Link] = [Link](_.extend(params, options));
[Link]('request', model, xhr, options);
return xhr;
};
 var noXhrPatch = typeof window !== 'undefined' && !![Link] &&
!([Link] && (new XMLHttpRequest).dispatchEvent);

// Map from CRUD to HTTP for our default `[Link]` implementation.

var methodMap = {
'create': 'POST',
'update': 'PUT',
'patch': 'PATCH',
'delete': 'DELETE',
'read': 'GET'
};

// Set the default implementation of `[Link]` to proxy through to `$`.

// Override this if you'd like to use a different library.
[Link] = function() {
return Backbone.$.[Link](Backbone.$, arguments);
};

// [Link]
// ---------------

// Routers map faux-URLs to actions, and fire events when routes are
// matched. Creating a new one sets its `routes` hash, if not set statically.
var Router = [Link] = function(options) {
options || (options = {});
if ([Link]) [Link] = [Link];
this._bindRoutes();
[Link](this, arguments);
};

// Cached regular expressions for matching named param parts and splatted
// parts of route strings.
var optionalParam = /\((.*?)\)/g;
var namedParam = /(\(\?)?:\w+/g;
var splatParam = /\*\w+/g;
var escapeRegExp = /[\-{}\[\]+?.,\\\^$|#\s]/g;

// Set up all inheritable **[Link]** properties and methods.

_.extend([Link], Events, {

// Initialize is an empty function by default. Override it with your own

// initialization logic.
initialize: function(){},

// Manually bind a single named route to a callback. For example:

//
// [Link]('search/:query/p:num', 'search', function(query, num) {
// ...
// });
//
route: function(route, name, callback) {
if (!_.isRegExp(route)) route = this._routeToRegExp(route);
if (_.isFunction(name)) {
callback = name;
name = '';
}
if (!callback) callback = this[name];
var router = this;
[Link](route, function(fragment) {
var args = router._extractParameters(route, fragment);
callback && [Link](router, args);
[Link](router, ['route:' + name].concat(args));
[Link]('route', name, args);
 [Link]('route', router, name, args);
});
return this;
},

// Simple proxy to `[Link]` to save a fragment into the history.

navigate: function(fragment, options) {
[Link](fragment, options);
return this;
},

// Bind all defined routes to `[Link]`. We have to reverse the

// order of the routes here to support behavior where the most general
// routes can be defined at the bottom of the route map.
_bindRoutes: function() {
if (![Link]) return;
[Link] = _.result(this, 'routes');
var route, routes = _.keys([Link]);
while ((route = [Link]()) != null) {
[Link](route, [Link][route]);
}
},

// Convert a route string into a regular expression, suitable for matching

// against the current location hash.
_routeToRegExp: function(route) {
route = [Link](escapeRegExp, '\\$&')
.replace(optionalParam, '(?:$1)?')
.replace(namedParam, function(match, optional) {
return optional ? match : '([^\/]+)';
})
.replace(splatParam, '(.*?)');
return new RegExp('^' + route + '$');
},

// Given a route, and a URL fragment that it matches, return the array of
// extracted decoded parameters. Empty or unmatched parameters will be
// treated as `null` to normalize cross-browser behavior.
_extractParameters: function(route, fragment) {
var params = [Link](fragment).slice(1);
return _.map(params, function(param) {
return param ? decodeURIComponent(param) : null;
});
}

});

// [Link]
// ----------------

// Handles cross-browser history management, based on either

// [pushState]([Link] and real URLs, or
// [onhashchange]([Link]
// and URL fragments. If the browser supports neither (old IE, natch),
// falls back to polling.
var History = [Link] = function() {
[Link] = [];
_.bindAll(this, 'checkUrl');

// Ensure that `History` can be used outside of the browser.

if (typeof window !== 'undefined') {
[Link] = [Link];
[Link] = [Link];
 }
};

// Cached regex for stripping a leading hash/slash and trailing space.

var routeStripper = /^[#\/]|\s+$/g;

// Cached regex for stripping leading and trailing slashes.

var rootStripper = /^\/+|\/+$/g;

// Cached regex for detecting MSIE.

var isExplorer = /msie [\w.]+/;

// Cached regex for removing a trailing slash.

var trailingSlash = /\/$/;

// Cached regex for stripping urls of hash and query.

var pathStripper = /[?#].*$/;

// Has the history handling already been started?

[Link] = false;

// Set up all inheritable **[Link]** properties and methods.

_.extend([Link], Events, {

// The default interval to poll for hash changes, if necessary, is

// twenty times a second.
interval: 50,

// Gets the true hash value. Cannot use [Link] directly due to bug
// in Firefox where [Link] will always be decoded.
getHash: function(window) {
var match = (window || this).[Link](/#(.*)$/);
return match ? match[1] : '';
},

// Get the cross-browser normalized URL fragment, either from the URL,
// the hash, or the override.
getFragment: function(fragment, forcePushState) {
if (fragment == null) {
if (this._hasPushState || !this._wantsHashChange || forcePushState) {
fragment = [Link];
var root = [Link](trailingSlash, '');
if () fragment = [Link]([Link]);
} else {
fragment = [Link]();
}
}
return [Link](routeStripper, '');
},

// Start the hash change handling, returning `true` if the current URL matches
// an existing route, and `false` otherwise.
start: function(options) {
if ([Link]) throw new Error("[Link] has already been
started");
[Link] = true;

// Figure out the initial configuration. Do we need an iframe?

// Is pushState desired ... is it available?
[Link] = _.extend({root: '/'}, [Link], options);
[Link] = [Link];
this._wantsHashChange = [Link] !== false;
this._wantsPushState = !![Link];
 this._hasPushState = !!([Link] && [Link] &&
[Link]);
var fragment = [Link]();
var docMode = [Link];
var oldIE = ([Link]([Link]()) &&
(!docMode || docMode <= 7));

// Normalize root to always include a leading and trailing slash.

[Link] = ('/' + [Link] + '/').replace(rootStripper, '/');

if (oldIE && this._wantsHashChange) {

[Link] = Backbone.$('<iframe src="javascript:0" tabindex="-1"
/>').hide().appendTo('body')[0].contentWindow;
[Link](fragment);
}

// Depending on whether we're using pushState or hashes, and whether

// 'onhashchange' is supported, determine how we check the URL state.
if (this._hasPushState) {
Backbone.$(window).on('popstate', [Link]);
} else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
Backbone.$(window).on('hashchange', [Link]);
} else if (this._wantsHashChange) {
this._checkUrlInterval = setInterval([Link], [Link]);
}

// Determine if we need to change the base url, for a pushState link

// opened by a non-pushState browser.
[Link] = fragment;
var loc = [Link];
var atRoot = [Link](/[^\/]$/, '$&/') === [Link];

// Transition from hashChange to pushState or vice versa if both are

// requested.
if (this._wantsHashChange && this._wantsPushState) {

// If we've started off with a route from a `pushState`-enabled

// browser, but we're currently in a browser that doesn't support it...
if (!this._hasPushState && !atRoot) {
[Link] = [Link](null, true);
[Link]([Link] + [Link] + '#' +
[Link]);
// Return immediately as browser will do redirect to new url
return true;

// Or if we've started out with a hash-based route, but we're currently

// in a browser where it could be `pushState`-based instead...
} else if (this._hasPushState && atRoot && [Link]) {
[Link] = [Link]().replace(routeStripper, '');
[Link]({}, [Link], [Link] + [Link] +
[Link]);
}

if (![Link]) return [Link]();

},

// Disable [Link], perhaps temporarily. Not useful in a real app,

// but possibly useful for unit testing Routers.
stop: function() {
Backbone.$(window).off('popstate', [Link]).off('hashchange',
[Link]);
 clearInterval(this._checkUrlInterval);
[Link] = false;
},

// Add a route to be tested when the fragment changes. Routes added later
// may override previous routes.
route: function(route, callback) {
[Link]({route: route, callback: callback});
},

// Checks the current URL to see if it has changed, and if it has,

// calls `loadUrl`, normalizing across the hidden iframe.
checkUrl: function(e) {
var current = [Link]();
if (current === [Link] && [Link]) {
current = [Link]([Link]([Link]));
}
if (current === [Link]) return false;
if ([Link]) [Link](current);
[Link]();
},

// Attempt to load the current URL fragment. If a route succeeds with a

// match, returns `true`. If no defined routes matches the fragment,
// returns `false`.
loadUrl: function(fragment) {
fragment = [Link] = [Link](fragment);
return _.any([Link], function(handler) {
if ([Link](fragment)) {
[Link](fragment);
return true;
}
});
},

// Save a fragment into the hash history, or replace the URL state if the
// 'replace' option is passed. You are responsible for properly URL-encoding
// the fragment in advance.
//
// The options object can contain `trigger: true` if you wish to have the
// route callback be fired (not usually desirable), or `replace: true`, if
// you wish to modify the current URL without adding an entry to the history.
navigate: function(fragment, options) {
if (![Link]) return false;
if (!options || options === true) options = {trigger: !!options};

var url = [Link] + (fragment = [Link](fragment || ''));

// Strip the fragment of the query and hash for matching.

fragment = [Link](pathStripper, '');

if ([Link] === fragment) return;

[Link] = fragment;

// Don't include a trailing slash on the root.

if (fragment === '' && url !== '/') url = [Link](0, -1);

// If pushState is available, we use it to set the fragment as a real URL.

if (this._hasPushState) {
[Link][[Link] ? 'replaceState' : 'pushState']({},
[Link], url);

// If hash changes haven't been explicitly disabled, update the hash

 // fragment to store history.
} else if (this._wantsHashChange) {
this._updateHash([Link], fragment, [Link]);
if ([Link] && (fragment !== [Link]([Link]([Link]))))
{
// Opening and closing the iframe tricks IE7 and earlier to push a
// history entry on hash-tag change. When replace is true, we don't
// want this.
if(![Link]) [Link]().close();
this._updateHash([Link], fragment, [Link]);
}

// If you've told us that you explicitly don't want fallback hashchange-

// based history, then `navigate` becomes a page refresh.
} else {
return [Link](url);
}
if ([Link]) return [Link](fragment);
},

// Update the hash location, either replacing the current entry, or adding
// a new one to the browser history.
_updateHash: function(location, fragment, replace) {
if (replace) {
var href = [Link](/(javascript:|#).*$/, '');
[Link](href + '#' + fragment);
} else {
// Some browsers require that `hash` contains a leading #.
[Link] = '#' + fragment;
}
}

});

// Create the default [Link].

[Link] = new History;

// Helpers
// -------

// Helper function to correctly set up the prototype chain, for subclasses.

// Similar to `[Link]`, but uses a hash of prototype properties and
// class properties to be extended.
var extend = function(protoProps, staticProps) {
var parent = this;
var child;

// The constructor function for the new subclass is either defined by you
// (the "constructor" property in your `extend` definition), or defaulted
// by us to simply call the parent's constructor.
if (protoProps && _.has(protoProps, 'constructor')) {
child = [Link];
} else {
child = function(){ return [Link](this, arguments); };
}

// Add static properties to the constructor function, if supplied.

_.extend(child, parent, staticProps);

// Set the prototype chain to inherit from `parent`, without calling

// `parent`'s constructor function.
var Surrogate = function(){ [Link] = child; };
[Link] = [Link];
 [Link] = new Surrogate;

// Add prototype properties (instance properties) to the subclass,

// if supplied.
if (protoProps) _.extend([Link], protoProps);

// Set a convenience property in case the parent's prototype is needed

// later.
child.__super__ = [Link];

return child;
};

// Set up inheritance for the model, collection, router, view and history.
[Link] = [Link] = [Link] = [Link] = [Link] =
extend;

// Throw an error when a URL is needed, and none is supplied.

var urlError = function() {
throw new Error('A "url" property or function must be specified');
};

// Wrap an optional error callback with a fallback error event.

var wrapError = function(model, options) {
var error = [Link];
[Link] = function(resp) {
if (error) error(model, resp, options);
[Link]('error', model, resp, options);
};
};

}).call(this);
 POS Models JS
[Link]('point_of_sale.models', function (require) {
"use strict";

var BarcodeParser = require('[Link]');

var PosDB = require('point_of_sale.DB');
var devices = require('point_of_sale.devices');
var core = require('[Link]');
var Model = require('[Link]');
var formats = require('[Link]');
var session = require('[Link]');
var time = require('[Link]');
var utils = require('[Link]');

var QWeb = [Link];

var _t = core._t;
var Mutex = [Link];
var round_di = utils.round_decimals;
var round_pr = utils.round_precision;
var Backbone = [Link];

var exports = {};

// The PosModel contains the Point Of Sale's representation of the backend.

// Since the PoS must work in standalone ( Without connection to the server )
// it must contains a representation of the server's PoS backend.
// (taxes, product list, configuration options, etc.) this representation
// is fetched and stored by the PosModel at the initialisation.
// this is done asynchronously, a ready deferred alows the GUI to wait interactively
// for the loading to be completed
// There is a single instance of the PosModel for each Front-End instance, it is
usually called
// 'pos' and is available to all widgets extending PosWidget.

[Link] = [Link]({
initialize: function(session, attributes) {
[Link](this, attributes);
var self = this;
this.flush_mutex = new Mutex(); // used to make sure the
orders are sent to the server once at time
[Link] = [Link];
[Link] = [Link];

[Link] = new [Link](this); // used to

communicate to the hardware devices via a local proxy
this.barcode_reader = new [Link]({'pos': this,
proxy:[Link]});

this.proxy_queue = new [Link](); // used to prevent

parallels communications to the proxy
[Link] = new PosDB(); // a local database used to
search trough products and categories & store pending orders
[Link] = [Link]; //debug mode

// Business data; loaded from the server at launch

this.company_logo = null;
this.company_logo_base64 = '';
[Link] = null;
[Link] = null;
[Link] = null;
[Link] = null;
 [Link] = [];
[Link] = [];
[Link] = null;
[Link] = [];
[Link] = [];
this.pos_session = null;
[Link] = null;
[Link] = [];
this.units_by_id = {};
[Link] = null;
this.order_sequence = 1;
[Link] = this;

// these dynamic attributes can be watched for change by other models or

widgets
[Link]({
'synch': { state:'connected', pending:0 },
'orders': new OrderCollection(),
'selectedOrder': null,
'selectedClient': null,
});

[Link]('orders').bind('remove', function(order,_unused_,options){
self.on_removed_order(order,[Link],[Link]);
});

// Forward the 'client' attribute on the selected order to 'selectedClient'

function update_client() {
var order = self.get_order();
[Link]('selectedClient', order ? order.get_client() : null );
}
[Link]('orders').bind('add remove change', update_client, this);
[Link]('change:selectedOrder', update_client, this);

// We fetch the backend data on the server asynchronously. this is done only
when the pos user interface is launched,
// Any change on this data made on the server is thus not reflected on the
point of sale until it is relaunched.
// when all the data has loaded, we compute some stuff, and declare the Pos
ready to be used.
[Link] = this.load_server_data().then(function(){
return self.after_load_server_data();
});
},
after_load_server_data: function(){
this.load_orders();
this.set_start_order();
if([Link].use_proxy){
return this.connect_to_proxy();
}
},
// releases ressources holds by the model at the end of life of the posmodel
destroy: function(){
// FIXME, should wait for flushing, return a deferred to indicate successfull
destruction
// [Link]();
[Link]();
this.barcode_reader.disconnect();
this.barcode_reader.disconnect_from_proxy();
},

connect_to_proxy: function(){
var self = this;
 var done = new $.Deferred();
this.barcode_reader.disconnect_from_proxy();
[Link].loading_message(_t('Connecting to the PosBox'),0);
[Link].loading_skip(function(){
[Link].stop_searching();
});
[Link]({
force_ip: [Link].proxy_ip || undefined,
progress: function(prog){
[Link].loading_progress(prog);
},
}).then(function(){
if([Link].iface_scan_via_proxy){
self.barcode_reader.connect_to_proxy();
}
}).always(function(){
[Link]();
});
return done;
},

// Server side model loaders. This is the list of the models that need to be
loaded from
// the server. The models are loaded one by one by this list's order. The 'loaded'
callback
// is used to store the data in the appropriate place once it has been loaded.
This callback
// can return a deferred that will pause the loading of the next module.
// a shared temporary dictionary is available for loaders to communicate private
variables
// used during loading such as object ids, etc.
models: [
{
label: 'version',
loaded: function(self){
return
[Link]('/web/webclient/version_info',{}).done(function(version) {
[Link] = version;
});
},

},{
model: '[Link]',
fields: ['name','company_id'],
ids: function(self){ return [[Link]]; },
loaded: function(self,users){ [Link] = users[0]; },
},{
model: '[Link]',
fields: [ 'currency_id', 'email', 'website', 'company_registry', 'vat',
'name', 'phone', 'partner_id' , 'country_id', 'tax_calculation_rounding_method'],
ids: function(self){ return [[Link].company_id[0]]; },
loaded: function(self,companies){ [Link] = companies[0]; },
},{
model: '[Link]',
fields: ['name','digits'],
loaded: function(self,dps){
[Link] = {};
for (var i = 0; i < [Link]; i++) {
[Link][dps[i].name] = dps[i].digits;
}
},
},{
model: '[Link]',
 fields: [],
domain: null,
context: function(self){ return { active_test: false }; },
loaded: function(self,units){
[Link] = units;
var units_by_id = {};
for(var i = 0, len = [Link]; i < len; i++){
units_by_id[units[i].id] = units[i];
units[i].groupable = ( units[i].category_id[0] === 1 );
units[i].is_unit = ( units[i].id === 1 );
}
self.units_by_id = units_by_id;
}
},{
model: '[Link]',
fields:
['name','street','city','state_id','country_id','vat','phone','zip','mobile','email','
barcode','write_date','property_account_position_id'],
domain: [['customer','=',true]],
loaded: function(self,partners){
[Link] = partners;
[Link].add_partners(partners);
},
},{
model: '[Link]',
fields: ['name'],
loaded: function(self,countries){
[Link] = countries;
[Link] = null;
for (var i = 0; i < [Link]; i++) {
if (countries[i].id === [Link].country_id[0]){
[Link] = countries[i];
}
}
},
},{
model: '[Link]',
fields: ['name','amount', 'price_include', 'include_base_amount',
'amount_type', 'children_tax_ids'],
domain: null,
loaded: function(self, taxes){
[Link] = taxes;
self.taxes_by_id = {};
_.each(taxes, function(tax){
self.taxes_by_id[[Link]] = tax;
});
_.each(self.taxes_by_id, function(tax) {
tax.children_tax_ids = _.map(tax.children_tax_ids, function
(child_tax_id) {
return self.taxes_by_id[child_tax_id];
});
});
},
},{
model: '[Link]',
fields: ['id',
'journal_ids','name','user_id','config_id','start_at','stop_at','sequence_number','log
in_number'],
domain: function(self){ return
[['state','=','opened'],['user_id','=',[Link]]]; },
loaded: function(self,pos_sessions){
self.pos_session = pos_sessions[0];
},
 },{
model: '[Link]',
fields: [],
domain: function(self){ return [['id','=', self.pos_session.config_id[0]]]; },
loaded: function(self,configs){
[Link] = configs[0];
[Link].use_proxy = [Link].iface_payment_terminal ||
[Link].iface_electronic_scale ||
[Link].iface_print_via_proxy ||
[Link].iface_scan_via_proxy ||
[Link].iface_cashdrawer;

if ([Link].company_id[0] !== [Link].company_id[0]) {

throw new Error(_t("Error: The Point of Sale User must belong to the
same company as the Point of Sale. You are probably trying to load the point of sale
as an administrator in a multi-company setup, with the administrator account set to
the wrong company."));
}

[Link].set_uuid([Link]);

var orders = [Link].get_orders();

for (var i = 0; i < [Link]; i++) {
self.pos_session.sequence_number =
[Link](self.pos_session.sequence_number, orders[i].data.sequence_number+1);
}
},
},{
model: '[Link]',
fields: ['name','pos_security_pin','groups_id','barcode'],
domain: function(self){ return
[['company_id','=',[Link].company_id[0]],'|', ['groups_id','=',
[Link].group_pos_manager_id[0]],['groups_id','=',
[Link].group_pos_user_id[0]]]; },
loaded: function(self,users){
// we attribute a role to the user, 'cashier' or 'manager', depending
// on the group the user belongs.
var pos_users = [];
for (var i = 0; i < [Link]; i++) {
var user = users[i];
for (var j = 0; j < user.groups_id.length; j++) {
var group_id = user.groups_id[j];
if (group_id === [Link].group_pos_manager_id[0]) {
[Link] = 'manager';
break;
} else if (group_id === [Link].group_pos_user_id[0]) {
[Link] = 'cashier';
}
}
if ([Link]) {
pos_users.push(user);
}
// replace the current user with its updated version
if ([Link] === [Link]) {
[Link] = user;
}
}
[Link] = pos_users;
},
},{
model: '[Link]',
fields: [],
ids: function(self){ return [[Link].stock_location_id[0]]; },
 loaded: function(self, locations){ [Link] = locations[0]; },
},{
model: '[Link]',
fields: ['currency_id'],
ids: function(self){ return [[Link].pricelist_id[0]]; },
loaded: function(self, pricelists){ [Link] = pricelists[0]; },
},{
model: '[Link]',
fields: ['name','symbol','position','rounding'],
ids: function(self){ return [[Link].currency_id[0]]; },
loaded: function(self, currencies){
[Link] = currencies[0];
if ([Link] > 0) {
[Link] = [Link]([Link](1.0 /
[Link]) / [Link](10));
} else {
[Link] = 0;
}

},
},{
model: '[Link]',
fields: ['id','name','parent_id','child_id','image'],
domain: null,
loaded: function(self, categories){
[Link].add_categories(categories);
},
},{
model: '[Link]',
fields: ['display_name', 'list_price','price','pos_categ_id', 'taxes_id',
'barcode', 'default_code',
'to_weight', 'uom_id', 'description_sale', 'description',
'product_tmpl_id','tracking'],
order: ['sequence','default_code','name'],
domain: [['sale_ok','=',true],['available_in_pos','=',true]],
context: function(self){ return { pricelist: [Link],
display_default_code: false }; },
loaded: function(self, products){
[Link].add_products(products);
},
},{
model: '[Link]',
fields:
['account_id','currency_id','journal_id','state','name','user_id','pos_session_id'],
domain: function(self){ return [['state', '=', 'open'],['pos_session_id', '=',
self.pos_session.id]]; },
loaded: function(self, cashregisters, tmp){
[Link] = cashregisters;

[Link] = [];
_.each(cashregisters,function(statement){
[Link](statement.journal_id[0]);
});
},
},{
model: '[Link]',
fields: ['type', 'sequence'],
domain: function(self,tmp){ return [['id','in',[Link]]]; },
loaded: function(self, journals){
var i;
[Link] = journals;

// associate the bank statements with their journals.

 var cashregisters = [Link];
var ilen = [Link];
for(i = 0; i < ilen; i++){
for(var j = 0, jlen = [Link]; j < jlen; j++){
if(cashregisters[i].journal_id[0] === journals[j].id){
cashregisters[i].journal = journals[j];
}
}
}

self.cashregisters_by_id = {};
for (i = 0; i < [Link]; i++) {
self.cashregisters_by_id[[Link][i].id] =
[Link][i];
}

[Link] = [Link](function(a,b){
// prefer cashregisters to be first in the list
if ([Link] == "cash" && [Link] != "cash") {
return -1;
} else if ([Link] != "cash" && [Link] == "cash") {
return 1;
} else {
return [Link] - [Link];
}
});

},
}, {
model: '[Link]',
fields: [],
domain: function(self){ return [['id','in',[Link].fiscal_position_ids]];
},
loaded: function(self, fiscal_positions){
self.fiscal_positions = fiscal_positions;
}
}, {
model: '[Link]',
fields: [],
domain: function(self){
var fiscal_position_tax_ids = [];

self.fiscal_positions.forEach(function (fiscal_position) {
fiscal_position.tax_ids.forEach(function (tax_id) {
fiscal_position_tax_ids.push(tax_id);
});
});

return [['id','in',fiscal_position_tax_ids]];
},
loaded: function(self, fiscal_position_taxes){
self.fiscal_position_taxes = fiscal_position_taxes;
self.fiscal_positions.forEach(function (fiscal_position) {
fiscal_position.fiscal_position_taxes_by_id = {};
fiscal_position.tax_ids.forEach(function (tax_id) {
var fiscal_position_tax = _.find(fiscal_position_taxes, function
(fiscal_position_tax) {
return fiscal_position_tax.id === tax_id;
});

fiscal_position.fiscal_position_taxes_by_id[fiscal_position_tax.id] =
fiscal_position_tax;
 });
});
}
}, {
label: 'fonts',
loaded: function(){
var fonts_loaded = new $.Deferred();
// Waiting for fonts to be loaded to prevent receipt printing
// from printing empty receipt while loading Inconsolata
// ( The font used for the receipt )
waitForWebfonts(['Lato','Inconsolata'], function(){
fonts_loaded.resolve();
});
// The JS used to detect font loading is not 100% robust, so
// do not wait more than 5sec
setTimeout(function(){
fonts_loaded.resolve();
},5000);

return fonts_loaded;
},
},{
label: 'pictures',
loaded: function(self){
self.company_logo = new Image();
var logo_loaded = new $.Deferred();
self.company_logo.onload = function(){
var img = self.company_logo;
var ratio = 1;
var targetwidth = 300;
var maxheight = 150;
if( [Link] !== targetwidth ){
ratio = targetwidth / [Link];
}
if( [Link] * ratio > maxheight ){
ratio = maxheight / [Link];
}
var width = [Link]([Link] * ratio);
var height = [Link]([Link] * ratio);
var c = [Link]('canvas');
[Link] = width;
[Link] = height;
var ctx = [Link]('2d');
[Link](self.company_logo,0,0, width, height);

self.company_logo_base64 = [Link]();
logo_loaded.resolve();
};
self.company_logo.onerror = function(){
logo_loaded.reject();
};
self.company_logo.crossOrigin = "anonymous";
self.company_logo.src = '/web/binary/company_logo' +'?dbname=' +
[Link] + '&_'+[Link]();

return logo_loaded;
},
}, {
label: 'barcodes',
loaded: function(self) {
var barcode_parser = new BarcodeParser({'nomenclature_id':
[Link].barcode_nomenclature_id});
self.barcode_reader.set_barcode_parser(barcode_parser);
 return barcode_parser.is_loaded();
},
}
],

// loads all the needed data on the sever. returns a deferred indicating when all
the data has loaded.
load_server_data: function(){
var self = this;
var loaded = new $.Deferred();
var progress = 0;
var progress_step = 1.0 / [Link];
var tmp = {}; // this is used to share a temporary state between models
loaders

function load_model(index){
if(index >= [Link]){
[Link]();
}else{
var model = [Link][index];
[Link].loading_message(_t('Loading')+' '+([Link] ||
[Link] || ''), progress);

var cond = typeof [Link] === 'function' ?

[Link](self,tmp) : true;
if (!cond) {
load_model(index+1);
return;
}

var fields = typeof [Link] === 'function' ?

[Link](self,tmp) : [Link];
var domain = typeof [Link] === 'function' ?
[Link](self,tmp) : [Link];
var context = typeof [Link] === 'function' ?
[Link](self,tmp) : [Link];
var ids = typeof [Link] === 'function' ?
[Link](self,tmp) : [Link];
var order = typeof [Link] === 'function' ?
[Link](self,tmp): [Link];
progress += progress_step;

var records;
if( [Link] ){
if ([Link]) {
records = new
Model([Link]).call('read',[ids,fields],context);
} else {
records = new Model([Link])
.query(fields)
.filter(domain)
.order_by(order)
.context(context)
.all();
}
[Link](function(result){
try{ // catching exceptions in [Link](...)
$.when([Link](self,result,tmp))
.then(function(){ load_model(index + 1); },
function(err){ [Link](err); });
}catch(err){
[Link]([Link]);
[Link](err);
 }
},function(err){
[Link](err);
});
}else if( [Link] ){
try{ // catching exceptions in [Link](...)
$.when([Link](self,tmp))
.then( function(){ load_model(index +1); },
function(err){ [Link](err); });
}catch(err){
[Link](err);
}
}else{
load_model(index + 1);
}
}
}

try{
load_model(0);
}catch(err){
[Link](err);
}

return loaded;
},

// reload the list of partner, returns as a deferred that resolves if there were
// updated partners, and fails if not
load_new_partners: function(){
var self = this;
var def = new $.Deferred();
var fields = _.find([Link],function(model){ return [Link] ===
'[Link]'; }).fields;
new Model('[Link]')
.query(fields)

.filter([['customer','=',true],['write_date','>',[Link].get_partner_write_date()]])
.all({'timeout':3000, 'shadow': true})
.then(function(partners){
if ([Link].add_partners(partners)) { // check if the partners we
got were real updates
[Link]();
} else {
[Link]();
}
}, function(err,event){ [Link](); [Link](); });
return def;
},

// this is called when an order is removed from the order collection. It ensures
that there is always an existing
// order and a valid selected order
on_removed_order: function(removed_order,index,reason){
var order_list = this.get_order_list();
if( (reason === 'abandon' || removed_order.temporary) && order_list.length >
0){
// when we intentionally remove an unfinished order, and there is another
existing one
this.set_order(order_list[index] || order_list[order_list.length -1]);
}else{
// when the order was automatically removed after completion,
// or when we intentionally delete the only concurrent order
 this.add_new_order();
}
},

// returns the user who is currently the cashier for this point of sale
get_cashier: function(){
return [Link] || [Link];
},
// changes the current cashier
set_cashier: function(user){
[Link] = user;
},
//creates a new empty order and sets it as the current order
add_new_order: function(){
var order = new [Link]({},{pos:this});
[Link]('orders').add(order);
[Link]('selectedOrder', order);
return order;
},
// load the locally saved unpaid orders for this session.
load_orders: function(){
var jsons = [Link].get_unpaid_orders();
var orders = [];
var not_loaded_count = 0;

for (var i = 0; i < [Link]; i++) {

var json = jsons[i];
if (json.pos_session_id === this.pos_session.id) {
[Link](new [Link]({},{
pos: this,
json: json,
}));
} else {
not_loaded_count += 1;
}
}

if (not_loaded_count) {
[Link]('There are '+not_loaded_count+' locally saved unpaid orders
belonging to another session');
}

orders = [Link](function(a,b){
return a.sequence_number - b.sequence_number;
});

if ([Link]) {
[Link]('orders').add(orders);
}
},

set_start_order: function(){
var orders = [Link]('orders').models;

if ([Link] && ) {

[Link]('selectedOrder',orders[0]);
} else {
this.add_new_order();
}
},

// return the current order

get_order: function(){
 return [Link]('selectedOrder');
},

get_client: function() {
var order = this.get_order();
if (order) {
return order.get_client();
}
return null;
},

// change the current order

set_order: function(order){
[Link]({ selectedOrder: order });
},

// return the list of unpaid orders

get_order_list: function(){
return [Link]('orders').models;
},

//removes the current order

delete_current_order: function(){
var order = this.get_order();
if (order) {
[Link]({'reason':'abandon'});
}
},

// saves the order locally and try to send it to the backend.

// it returns a deferred that succeeds after having tried to send the order and
all the other pending orders.
push_order: function(order, opts) {
opts = opts || {};
var self = this;

if(order){
[Link].add_order(order.export_as_JSON());
}

var pushed = new $.Deferred();

this.flush_mutex.exec(function(){
var flushed = self._flush_orders([Link].get_orders(), opts);

[Link](function(ids){
[Link]();
});

return flushed;
});
return pushed;
},

// saves the order locally and try to send it to the backend and make an invoice
// returns a deferred that succeeds when the order has been posted and
successfully generated
// an invoice. This method can fail in various ways:
// error-no-client: the order must have an associated partner_id. You can retry to
make an invoice once
// this error is solved
// error-transfer: there was a connection error during the transfer. You can retry
to make the invoice once
 // the network connection is up

push_and_invoice_order: function(order){
var self = this;
var invoiced = new $.Deferred();

if(!order.get_client()){
[Link]({code:400, message:'Missing Customer', data:{}});
return invoiced;
}

var order_id = [Link].add_order(order.export_as_JSON());

this.flush_mutex.exec(function(){
var done = new $.Deferred(); // holds the mutex

// send the order to the server

// we have a 30 seconds timeout on this push.
// FIXME: if the server takes more than 30 seconds to accept the order,
// the client will believe it wasn't successfully sent, and very bad
// things will happen as a duplicate will be sent next time
// so we must make sure the server detects and ignores duplicated orders

var transfer = self._flush_orders([[Link].get_order(order_id)],

{timeout:30000, to_invoice:true});

[Link](function(error){
[Link](error);
[Link]();
});

// on success, get the order id generated by the server

[Link](function(order_server_id){

// generate the pdf and download it

[Link].do_action('point_of_sale.pos_invoice_report',{additional_context:{
active_ids:order_server_id,
}});

[Link]();
[Link]();
});

return done;

});

return invoiced;
},

// wrapper around the _save_to_server that updates the synch status widget
_flush_orders: function(orders, options) {
var self = this;
[Link]('synch',{ state: 'connecting', pending: [Link]});

return self._save_to_server(orders, options).done(function (server_ids) {

var pending = [Link].get_orders().length;

[Link]('synch', {
state: pending ? 'connecting' : 'connected',
pending: pending
});
 return server_ids;
}).fail(function(error, event){
var pending = [Link].get_orders().length;
if ([Link]('failed')) {
[Link]('synch', { state: 'error', pending: pending });
} else {
[Link]('synch', { state: 'disconnected', pending: pending });
}
});
},

// send an array of orders to the server

// available options:
// - timeout: timeout for the rpc call in ms
// returns a deferred that resolves with the list of
// server generated ids for the sent orders
_save_to_server: function (orders, options) {
if (!orders || ![Link]) {
var result = $.Deferred();
[Link]([]);
return result;
}

options = options || {};

var self = this;

var timeout = typeof [Link] === 'number' ? [Link] : 7500 *
[Link];

// Keep the order ids that are about to be sent to the

// backend. In between create_from_ui and the success callback
// new orders may have been added to it.
var order_ids_to_sync = _.pluck(orders, 'id');

// we try to send the order. shadow prevents a spinner if it takes too long.
(unless we are sending an invoice,
// then we want to notify the user that we are waiting on something )
var posOrderModel = new Model('[Link]');
return [Link]('create_from_ui',
[_.map(orders, function (order) {
order.to_invoice = options.to_invoice || false;
return order;
})],
undefined,
{
shadow: !options.to_invoice,
timeout: timeout
}
).then(function (server_ids) {
_.each(order_ids_to_sync, function (order_id) {
[Link].remove_order(order_id);
});
[Link]('failed',false);
return server_ids;
}).fail(function (error, event){
if([Link] === 200 ){ // Business Logic Error, not a connection
problem
//if warning do not need to display traceback!!
if ([Link].exception_type == 'warning') {
delete [Link];
}
 // Hide error if already shown before ...
if (( || options.show_error) &&
!options.to_invoice) {
[Link].show_popup('error-traceback',{
'title': [Link],
'body': [Link]
});
}
[Link]('failed',error)
}
// prevent an error popup creation by the rpc failure
// we want the failure to be silent as we send the orders in the
background
[Link]();
[Link]('Failed to send orders:', orders);
});
},

scan_product: function(parsed_code){
var selectedOrder = this.get_order();
var product = [Link].get_product_by_barcode(parsed_code.base_code);

if(!product){
return false;
}

if(parsed_code.type === 'price'){

selectedOrder.add_product(product, {price:parsed_code.value});
}else if(parsed_code.type === 'weight'){
selectedOrder.add_product(product, {quantity:parsed_code.value,
merge:false});
}else if(parsed_code.type === 'discount'){
selectedOrder.add_product(product, {discount:parsed_code.value,
merge:false});
}else{
selectedOrder.add_product(product);
}
return true;
},

// Exports the paid orders (the ones waiting for internet connection)
export_paid_orders: function() {
return [Link]({
'paid_orders': [Link].get_orders(),
'session': this.pos_session.name,
'session_id': this.pos_session.id,
'date': (new Date()).toUTCString(),
'version': [Link].server_version_info,
},null,2);
},

// Exports the unpaid orders (the tabs)

export_unpaid_orders: function() {
return [Link]({
'unpaid_orders': [Link].get_unpaid_orders(),
'session': this.pos_session.name,
'session_id': this.pos_session.id,
'date': (new Date()).toUTCString(),
'version': [Link].server_version_info,
},null,2);
},

// This imports paid or unpaid orders from a json file whose

// contents are provided as the string str.
// It returns a report of what could and what could not be
// imported.
import_orders: function(str) {
var json = [Link](str);
var report = {
// Number of paid orders that were imported
paid: 0,
// Number of unpaid orders that were imported
unpaid: 0,
// Orders that were not imported because they already exist (uid conflict)
unpaid_skipped_existing: 0,
// Orders that were not imported because they belong to another session
unpaid_skipped_session: 0,
// The list of session ids to which skipped orders belong.
unpaid_skipped_sessions: [],
};

if (json.paid_orders) {
for (var i = 0; i < json.paid_orders.length; i++) {
[Link].add_order(json.paid_orders[i].data);
}
[Link] = json.paid_orders.length;
this.push_order();
}

if (json.unpaid_orders) {

var orders = [];

var existing = this.get_order_list();
var existing_uids = {};
var skipped_sessions = {};

for (var i = 0; i < [Link]; i++) {

existing_uids[existing[i].uid] = true;
}

for (var i = 0; i < json.unpaid_orders.length; i++) {

var order = json.unpaid_orders[i];
if (order.pos_session_id !== this.pos_session.id) {
report.unpaid_skipped_session += 1;
skipped_sessions[order.pos_session_id] = true;
} else if (existing_uids[[Link]]) {
report.unpaid_skipped_existing += 1;
} else {
[Link](new [Link]({},{
pos: this,
json: order,
}));
}
}

orders = [Link](function(a,b){
return a.sequence_number - b.sequence_number;
});

if ([Link]) {
[Link] = [Link];
[Link]('orders').add(orders);
}

report.unpaid_skipped_sessions = _.keys(skipped_sessions);
}
 return report;
},

_load_orders: function(){
var jsons = [Link].get_unpaid_orders();
var orders = [];
var not_loaded_count = 0;

for (var i = 0; i < [Link]; i++) {

var json = jsons[i];
if (json.pos_session_id === this.pos_session.id) {
[Link](new [Link]({},{
pos: this,
json: json,
}));
} else {
not_loaded_count += 1;
}
}

if (not_loaded_count) {
[Link]('There are '+not_loaded_count+' locally saved unpaid orders
belonging to another session');
}

orders = [Link](function(a,b){
return a.sequence_number - b.sequence_number;
});

if ([Link]) {
[Link]('orders').add(orders);
}
},

});

// Add fields to the list of read fields when a model is loaded

// by the point of sale.
// e.g: module.load_fields("[Link]",['price','category'])

exports.load_fields = function(model_name, fields) {

if (!(fields instanceof Array)) {
fields = [fields];
}

var models = [Link];

for (var i = 0; i < [Link]; i++) {
var model = models[i];
if ([Link] === model_name) {
// if 'fields' is empty all fields are loaded, so we do not need
// to modify the array
if (([Link] instanceof Array) && [Link] > 0) {
[Link] = [Link](fields || []);
}
}
}
};

// Loads openerp models at the point of sale startup.

// load_models take an array of model loader declarations.
// - The models will be loaded in the array order.
// - If no openerp model name is provided, no server data
// will be loaded, but the system can be used to preprocess
// data before load.
// - loader arguments can be functions that return a dynamic
// value. The function takes the PosModel as the first argument
// and a temporary object that is shared by all models, and can
// be used to store transient information between model loads.
// - There is no dependency management. The models must be loaded
// in the right order. Newly added models are loaded at the end
// but the after / before options can be used to load directly
// before / after another model.
//
// models: [{
// model: [string] the name of the openerp model to load.
// label: [string] The label displayed during load.
// fields: [[string]|function] the list of fields to be loaded.
// Empty Array / Null loads all fields.
// order: [[string]|function] the models will be ordered by
// the provided fields
// domain: [domain|function] the domain that determines what
// models need to be loaded. Null loads everything
// ids: [[id]|function] the id list of the models that must
// be loaded. Overrides domain.
// context: [Dict|function] the openerp context for the model read
// condition: [function] do not load the models if it evaluates to
// false.
// loaded: [function(self,model)] this function is called once the
// models have been loaded, with the data as second argument
// if the function returns a deferred, the next model will
// wait until it resolves before loading.
// }]
//
// options:
// before: [string] The model will be loaded before the named models
// (applies to both model name and label)
// after: [string] The model will be loaded after the (last loaded)
// named model. (applies to both model name and label)
//
exports.load_models = function(models,options) {
options = options || {};
if (!(models instanceof Array)) {
models = [models];
}

var pmodels = [Link];

var index = [Link];
if ([Link]) {
for (var i = 0; i < [Link]; i++) {
if ( pmodels[i].model === [Link] ||
pmodels[i].label === [Link] ){
index = i;
break;
}
}
} else if ([Link]) {
for (var i = 0; i < [Link]; i++) {
if ( pmodels[i].model === [Link] ||
pmodels[i].label === [Link] ){
index = i + 1;
}
}
}
[Link](pmodels,[index,0].concat(models));
};
var orderline_id = 1;

// An orderline represent one element of the content of a client's shopping cart.

// An orderline contains a product, its quantity, its price, discount. etc.
// An Order contains zero or more Orderlines.
[Link] = [Link]({
initialize: function(attr,options){
[Link] = [Link];
[Link] = [Link];
if ([Link]) {
this.init_from_JSON([Link]);
return;
}
[Link] = [Link];
this.set_product_lot([Link])
[Link] = [Link];
this.set_quantity(1);
[Link] = 0;
[Link] = '0';
[Link] = 'unit';
[Link] = false;
[Link] = orderline_id++;
},
init_from_JSON: function(json) {
[Link] = [Link].get_product_by_id(json.product_id);
if (![Link]) {
[Link]('ERROR: attempting to recover product ID', json.product_id,
'not available in the point of sale. Correct the product or clean the
browser cache.');
}
this.set_product_lot([Link])
[Link] = json.price_unit;
this.set_discount([Link]);
this.set_quantity([Link]);
[Link] = [Link];
orderline_id = [Link]([Link]+1,orderline_id);
var pack_lot_lines = json.pack_lot_ids;
for (var i = 0; i < pack_lot_lines.length; i++) {
var packlotline = pack_lot_lines[i][2];
var pack_lot_line = new [Link]({}, {'json':
_.extend(packlotline, {'order_line':this})});
this.pack_lot_lines.add(pack_lot_line);
}
},
clone: function(){
var orderline = new [Link]({},{
pos: [Link],
order: [Link],
product: [Link],
price: [Link],
});
[Link] = null;
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
[Link] = false;
return orderline;
},
set_product_lot: function(product){
this.has_product_lot = [Link] !== 'none';
this.pack_lot_lines = this.has_product_lot && new PacklotlineCollection(null,
{'order_line': this});
},
// sets a discount [0,100]%
set_discount: function(discount){
var disc = [Link]([Link](parseFloat(discount) || 0, 0),100);
[Link] = disc;
[Link] = '' + disc;
[Link]('change',this);
},
// returns the discount [0,100]%
get_discount: function(){
return [Link];
},
get_discount_str: function(){
return [Link];
},
get_product_type: function(){
return [Link];
},
// sets the quantity of the product. The quantity will be rounded according to the
// product's unity of measure properties. Quantities greater than zero will not
get
// rounded to zero
set_quantity: function(quantity){
[Link].assert_editable();
if(quantity === 'remove'){
[Link].remove_orderline(this);
return;
}else{
var quant = parseFloat(quantity) || 0;
var unit = this.get_unit();
if(unit){
if ([Link]) {
[Link] = round_pr(quant, [Link]);
var decimals = [Link]['Product Unit of Measure'];
[Link] = formats.format_value(round_di([Link],
decimals), { type: 'float', digits: [69, decimals]});
} else {
[Link] = round_pr(quant, 1);
[Link] = [Link](0);
}
}else{
[Link] = quant;
[Link] = '' + [Link];
}
}
[Link]('change',this);
},
// return the quantity of product
get_quantity: function(){
return [Link];
},
get_quantity_str: function(){
return [Link];
},
get_quantity_str_with_unit: function(){
var unit = this.get_unit();
if(unit && !unit.is_unit){
return [Link] + ' ' + [Link];
}else{
return [Link];
}
},
 compute_lot_lines: function(){
var pack_lot_lines = this.pack_lot_lines;
var lines = pack_lot_lines.length;
if([Link] > lines){
for(var i=0; i<[Link] - lines; i++){
pack_lot_lines.add(new [Link]({}, {'order_line': this}));
}
}
if([Link] < lines){
var to_remove = lines - [Link];
var lot_lines = pack_lot_lines.sortBy('lot_name').slice(0, to_remove);
pack_lot_lines.remove(lot_lines);
}
return this.pack_lot_lines;
},

has_valid_product_lot: function(){
if(!this.has_product_lot){
return true;
}
var valid_product_lot = this.pack_lot_lines.get_valid_lots();
return [Link] === valid_product_lot.length;
},

// return the unit of measure of the product

get_unit: function(){
var unit_id = [Link].uom_id;
if(!unit_id){
return undefined;
}
unit_id = unit_id[0];
if(![Link]){
return undefined;
}
return [Link].units_by_id[unit_id];
},
// return the product of this orderline
get_product: function(){
return [Link];
},
// selects or deselects this orderline
set_selected: function(selected){
[Link] = selected;
[Link]('change',this);
},
// returns true if this orderline is selected
is_selected: function(){
return [Link];
},
// when we add an new orderline we want to merge it with the last line to see
reduce the number of items
// in the orderline. This returns true if it makes sense to merge the two
can_be_merged_with: function(orderline){
if( this.get_product().id !== orderline.get_product().id){ //only orderline
of the same product can be merged
return false;
}else if(!this.get_unit() || !this.get_unit().groupable){
return false;
}else if(this.get_product_type() !== orderline.get_product_type()){
return false;
}else if(this.get_discount() > 0){ // we don't merge discounted
orderlines
 return false;
}else if([Link] !== [Link]){
return false;
}else{
return true;
}
},
merge: function(orderline){
[Link].assert_editable();
this.set_quantity(this.get_quantity() + orderline.get_quantity());
},
export_as_JSON: function() {
var pack_lot_ids = [];
if (this.has_product_lot){
this.pack_lot_lines.each(_.bind( function(item) {
return pack_lot_ids.push([0, 0, item.export_as_JSON()]);
}, this));
}
return {
qty: this.get_quantity(),
price_unit: this.get_unit_price(),
discount: this.get_discount(),
product_id: this.get_product().id,
tax_ids: [[6, false, _.map(this.get_applicable_taxes(), function(tax){
return [Link]; })]],
id: [Link],
pack_lot_ids: pack_lot_ids
};
},
//used to create a json of the ticket, to be sent to the printer
export_for_printing: function(){
return {
quantity: this.get_quantity(),
unit_name: this.get_unit().name,
price: this.get_unit_display_price(),
discount: this.get_discount(),
product_name: this.get_product().display_name,
product_name_wrapped: this.generate_wrapped_product_name(),
price_display : this.get_display_price(),
price_with_tax : this.get_price_with_tax(),
price_without_tax: this.get_price_without_tax(),
tax: this.get_tax(),
product_description: this.get_product().description,
product_description_sale: this.get_product().description_sale,
};
},
generate_wrapped_product_name: function() {
var MAX_LENGTH = 24; // 40 * line ratio of .6
var wrapped = [];
var name = this.get_product().display_name;
var current_line = "";

while ([Link] > 0) {

var space_index = [Link](" ");

if (space_index === -1) {

space_index = [Link];
}

if (current_line.length + space_index > MAX_LENGTH) {

if (current_line.length) {
[Link](current_line);
}
 current_line = "";
}

current_line += [Link](0, space_index + 1);

name = [Link](space_index + 1);
}

if (current_line.length) {
[Link](current_line);
}

return wrapped;
},
// changes the base price of the product for this orderline
set_unit_price: function(price){
[Link].assert_editable();
[Link] = round_di(parseFloat(price) || 0, [Link]['Product Price']);
[Link]('change',this);
},
get_unit_price: function(){
var digits = [Link]['Product Price'];
// round and truncate to mimic _sybmbol_set behavior
return parseFloat(round_di([Link] || 0, digits).toFixed(digits));
},
get_unit_display_price: function(){
if ([Link].iface_tax_included) {
var quantity = [Link];
[Link] = 1.0;
var price = this.get_all_prices().priceWithTax;
[Link] = quantity;
return price;
} else {
return this.get_unit_price();
}
},
get_base_price: function(){
var rounding = [Link];
return round_pr(this.get_unit_price() * this.get_quantity() * (1 -
this.get_discount()/100), rounding);
},
get_display_price: function(){
if ([Link].iface_tax_included) {
return this.get_price_with_tax();
} else {
return this.get_base_price();
}
},
get_price_without_tax: function(){
return this.get_all_prices().priceWithoutTax;
},
get_price_with_tax: function(){
return this.get_all_prices().priceWithTax;
},
get_tax: function(){
return this.get_all_prices().tax;
},
get_applicable_taxes: function(){
var i;
// Shenaningans because we need
// to keep the taxes ordering.
var ptaxes_ids = this.get_product().taxes_id;
var ptaxes_set = {};
for (i = 0; i < ptaxes_ids.length; i++) {
 ptaxes_set[ptaxes_ids[i]] = true;
}
var taxes = [];
for (i = 0; i < [Link]; i++) {
if (ptaxes_set[[Link][i].id]) {
[Link]([Link][i]);
}
}
return taxes;
},
get_tax_details: function(){
return this.get_all_prices().taxDetails;
},
get_taxes: function(){
var taxes_ids = this.get_product().taxes_id;
var taxes = [];
for (var i = 0; i < taxes_ids.length; i++) {
[Link]([Link].taxes_by_id[taxes_ids[i]]);
}
return taxes;
},
_map_tax_fiscal_position: function(tax) {
var current_order = [Link].get_order();
var order_fiscal_position = current_order && current_order.fiscal_position;

if (order_fiscal_position) {
var mapped_tax = _.find(order_fiscal_position.fiscal_position_taxes_by_id,
function (fiscal_position_tax) {
return fiscal_position_tax.tax_src_id[0] === [Link];
});

if (mapped_tax) {
tax = [Link].taxes_by_id[mapped_tax.tax_dest_id[0]];
}
}

return tax;
},
_compute_all: function(tax, base_amount, quantity) {
if (tax.amount_type === 'fixed') {
var sign_base_amount = base_amount >= 0 ? 1 : -1;
return ([Link]([Link]) * sign_base_amount) * quantity;
}
if ((tax.amount_type === 'percent' && !tax.price_include) || (tax.amount_type
=== 'division' && tax.price_include)){
return base_amount * [Link] / 100;
}
if (tax.amount_type === 'percent' && tax.price_include){
return base_amount - (base_amount / (1 + [Link] / 100));
}
if (tax.amount_type === 'division' && !tax.price_include) {
return base_amount / (1 - [Link] / 100) - base_amount;
}
return false;
},
compute_all: function(taxes, price_unit, quantity, currency_rounding, no_map_tax)
{
var self = this;
var list_taxes = [];
var currency_rounding_bak = currency_rounding;
if ([Link].tax_calculation_rounding_method == "round_globally"){
currency_rounding = currency_rounding * 0.00001;
}
 var total_excluded = round_pr(price_unit * quantity, currency_rounding);
var total_included = total_excluded;
var base = total_excluded;
_(taxes).each(function(tax) {
if (!no_map_tax){
tax = self._map_tax_fiscal_position(tax);
}
if (tax.amount_type === 'group'){
var ret = self.compute_all(tax.children_tax_ids, price_unit, quantity,
currency_rounding);
total_excluded = ret.total_excluded;
base = ret.total_excluded;
total_included = ret.total_included;
list_taxes = list_taxes.concat([Link]);
}
else {
var tax_amount = self._compute_all(tax, base, quantity);
tax_amount = round_pr(tax_amount, currency_rounding);

if (tax_amount){
if (tax.price_include) {
total_excluded -= tax_amount;
base -= tax_amount;
}
else {
total_included += tax_amount;
}
if (tax.include_base_amount) {
base += tax_amount;
}
var data = {
id: [Link],
amount: tax_amount,
name: [Link],
};
list_taxes.push(data);
}
}
});
return {
taxes: list_taxes,
total_excluded: round_pr(total_excluded, currency_rounding_bak),
total_included: round_pr(total_included, currency_rounding_bak)
};
},
get_all_prices: function(){
var price_unit = this.get_unit_price() * (1.0 - (this.get_discount() /
100.0));
var taxtotal = 0;

var product = this.get_product();

var taxes_ids = product.taxes_id;
var taxes = [Link];
var taxdetail = {};
var product_taxes = [];

_(taxes_ids).each(function(el){
product_taxes.push(_.detect(taxes, function(t){
return [Link] === el;
}));
});

var all_taxes = this.compute_all(product_taxes, price_unit,

this.get_quantity(), [Link]);
_(all_taxes.taxes).each(function(tax) {
taxtotal += [Link];
taxdetail[[Link]] = [Link];
});

return {
"priceWithTax": all_taxes.total_included,
"priceWithoutTax": all_taxes.total_excluded,
"tax": taxtotal,
"taxDetails": taxdetail,
};
},
});

var OrderlineCollection = [Link]({

model: [Link],
});

[Link] = [Link]({
defaults: {
lot_name: null
},
initialize: function(attributes, options){
this.order_line = options.order_line;
if ([Link]) {
this.init_from_JSON([Link]);
return;
}
},

init_from_JSON: function(json) {
this.order_line = json.order_line;
this.set_lot_name(json.lot_name);
},

set_lot_name: function(name){
[Link]({lot_name : _.[Link](name) || null});
},

get_lot_name: function(){
return [Link]('lot_name');
},

export_as_JSON: function(){
return {
lot_name: this.get_lot_name(),
};
},

add: function(){
var order_line = this.order_line,
index = [Link](this);
var new_lot_model = new [Link]({}, {'order_line':
this.order_line});
[Link](new_lot_model, {at: index + 1});
return new_lot_model;
},

remove: function(){
[Link](this);
}
});
var PacklotlineCollection = [Link]({
model: [Link],
initialize: function(models, options) {
this.order_line = options.order_line;
},

get_empty_model: function(){
return [Link]({'lot_name': null});
},

remove_empty_model: function(){
[Link]([Link]({'lot_name': null}));
},

get_valid_lots: function(){
return [Link](function(model){
return [Link]('lot_name');
});
},

set_quantity_by_lot: function() {
var valid_lots = this.get_valid_lots();
this.order_line.set_quantity(valid_lots.length);
}
});

// Every Paymentline contains a cashregister and an amount of money.

[Link] = [Link]({
initialize: function(attributes, options) {
[Link] = [Link];
[Link] = [Link];
[Link] = 0;
[Link] = false;
if ([Link]) {
this.init_from_JSON([Link]);
return;
}
[Link] = [Link];
[Link] = [Link].journal_id[1];
},
init_from_JSON: function(json){
[Link] = [Link];
[Link] = [Link].cashregisters_by_id[json.statement_id];
[Link] = [Link].journal_id[1];
},
//sets the amount of money on this payment line
set_amount: function(value){
[Link].assert_editable();
[Link] = round_di(parseFloat(value) || 0, [Link]);
[Link]('change',this);
},
// returns the amount of money on this paymentline
get_amount: function(){
return [Link];
},
get_amount_str: function(){
return formats.format_value([Link], {
type: 'float', digits: [69, [Link]]
});
},
set_selected: function(selected){
if([Link] !== selected){
 [Link] = selected;
[Link]('change',this);
}
},
// returns the payment type: 'cash' | 'bank'
get_type: function(){
return [Link];
},
// returns the associated cashregister
//exports as JSON for server communication
export_as_JSON: function(){
return {
name: time.datetime_to_str(new Date()),
statement_id: [Link],
account_id: [Link].account_id[0],
journal_id: [Link].journal_id[0],
amount: this.get_amount()
};
},
//exports as JSON for receipt printing
export_for_printing: function(){
return {
amount: this.get_amount(),
journal: [Link].journal_id[1],
};
},
});

var PaymentlineCollection = [Link]({

model: [Link],
});

// An order more or less represents the content of a client's shopping cart (the
OrderLines)
// plus the associated payment information (the Paymentlines)
// there is always an active ('selected') order in the Pos, a new one is created
// automaticaly once an order is completed and sent to the server.
[Link] = [Link]({
initialize: function(attributes,options){
[Link](this, arguments);
var self = this;
options = options || {};

this.init_locked = true;
[Link] = [Link];
this.selected_orderline = undefined;
this.selected_paymentline = undefined;
this.screen_data = {}; // see Gui
[Link] = [Link] || false;
this.creation_date = new Date();
this.to_invoice = false;
[Link] = new OrderlineCollection();
[Link] = new PaymentlineCollection();
this.pos_session_id = [Link].pos_session.id;
[Link] = false; // if true, cannot be modified.

[Link]({ client: null });

if ([Link]) {
this.init_from_JSON([Link]);
} else {
this.sequence_number = [Link].pos_session.sequence_number++;
[Link] = this.generate_unique_id();
 [Link] = _t("Order ") + [Link];
this.validation_date = undefined;
this.fiscal_position = _.find([Link].fiscal_positions, function(fp) {
return [Link] === [Link].default_fiscal_position_id[0];
});
}

[Link]('change', function(){ this.save_to_db("order:change"); },

this);
[Link]('change', function(){
this.save_to_db("orderline:change"); }, this);
[Link]('add', function(){ this.save_to_db("orderline:add");
}, this);
[Link]('remove', function(){
this.save_to_db("orderline:remove"); }, this);
[Link]('change', function(){
this.save_to_db("paymentline:change"); }, this);
[Link]('add', function(){ this.save_to_db("paymentline:add");
}, this);
[Link]('remove', function(){ this.save_to_db("paymentline:rem");
}, this);

this.init_locked = false;
this.save_to_db();

return this;
},
save_to_db: function(){
if (![Link] && !this.init_locked) {
[Link].save_unpaid_order(this);
}
},
init_from_JSON: function(json) {
var client;
this.sequence_number = json.sequence_number;
[Link].pos_session.sequence_number =
[Link](this.sequence_number+1,[Link].pos_session.sequence_number);
this.session_id = json.pos_session_id;
[Link] = [Link];
[Link] = _t("Order ") + [Link];
this.validation_date = json.creation_date;

if (json.fiscal_position_id) {
var fiscal_position = _.find([Link].fiscal_positions, function (fp) {
return [Link] === json.fiscal_position_id;
});

if (fiscal_position) {
this.fiscal_position = fiscal_position;
} else {
[Link]('ERROR: trying to load a fiscal position not available
in the pos');
}
}

if (json.partner_id) {
client = [Link].get_partner_by_id(json.partner_id);
if (!client) {
[Link]('ERROR: trying to load a parner not available in the
pos');
}
} else {
client = null;
 }
this.set_client(client);

[Link] = false; // FIXME

this.to_invoice = false; // FIXME

var orderlines = [Link];

for (var i = 0; i < [Link]; i++) {
var orderline = orderlines[i][2];
this.add_orderline(new [Link]({}, {pos: [Link], order: this,
json: orderline}));
}

var paymentlines = json.statement_ids;

for (var i = 0; i < [Link]; i++) {
var paymentline = paymentlines[i][2];
var newpaymentline = new [Link]({},{pos: [Link], order:
this, json: paymentline});
[Link](newpaymentline);

if (i === [Link] - 1) {
this.select_paymentline(newpaymentline);
}
}
},
export_as_JSON: function() {
var orderLines, paymentLines;
orderLines = [];
[Link](_.bind( function(item) {
return [Link]([0, 0, item.export_as_JSON()]);
}, this));
paymentLines = [];
[Link](_.bind( function(item) {
return [Link]([0, 0, item.export_as_JSON()]);
}, this));
return {
name: this.get_name(),
amount_paid: this.get_total_paid(),
amount_total: this.get_total_with_tax(),
amount_tax: this.get_total_tax(),
amount_return: this.get_change(),
lines: orderLines,
statement_ids: paymentLines,
pos_session_id: this.pos_session_id,
partner_id: this.get_client() ? this.get_client().id : false,
user_id: [Link] ? [Link] : [Link],
uid: [Link],
sequence_number: this.sequence_number,
creation_date: this.validation_date || this.creation_date, // todo: rename
creation_date in master
fiscal_position_id: this.fiscal_position ? this.fiscal_position.id : false
};
},
export_for_printing: function(){
var orderlines = [];
var self = this;

[Link](function(orderline){
[Link](orderline.export_for_printing());
});

var paymentlines = [];

[Link](function(paymentline){
 [Link](paymentline.export_for_printing());
});
var client = [Link]('client');
var cashier = [Link] || [Link];
var company = [Link];
var shop = [Link];
var date = new Date();

function is_xml(subreceipt){
return subreceipt ? ([Link]('\n')[0].indexOf('<!DOCTYPE QWEB')
>= 0) : false;
}

function render_xml(subreceipt){
if (!is_xml(subreceipt)) {
return subreceipt;
} else {
subreceipt = [Link]('\n').slice(1).join('\n');
var qweb = new [Link]();
[Link] = [Link];
qweb.default_dict = _.clone(QWeb.default_dict);
qweb.add_template('<templates><t t-
name="subreceipt">'+subreceipt+'</t></templates>');

return
[Link]('subreceipt',{'pos':[Link],'widget':[Link],'order':self,
'receipt': receipt}) ;
}
}

var receipt = {
orderlines: orderlines,
paymentlines: paymentlines,
subtotal: this.get_subtotal(),
total_with_tax: this.get_total_with_tax(),
total_without_tax: this.get_total_without_tax(),
total_tax: this.get_total_tax(),
total_paid: this.get_total_paid(),
total_discount: this.get_total_discount(),
tax_details: this.get_tax_details(),
change: this.get_change(),
name : this.get_name(),
client: client ? [Link] : null ,
invoice_id: null, //TODO
cashier: cashier ? [Link] : null,
precision: {
price: 2,
money: 2,
quantity: 3,
},
date: {
year: [Link](),
month: [Link](),
date: [Link](), // day of the month
day: [Link](), // day of the week
hour: [Link](),
minute: [Link]() ,
isostring: [Link](),
localestring: [Link](),
},
company:{
email: [Link],
website: [Link],
 company_registry: company.company_registry,
contact_address: company.partner_id[1],
vat: [Link],
name: [Link],
phone: [Link],
logo: [Link].company_logo_base64,
},
shop:{
name: [Link],
},
currency: [Link],
};

if (is_xml([Link].receipt_header)){
[Link] = '';
receipt.header_xml = render_xml([Link].receipt_header);
} else {
[Link] = [Link].receipt_header || '';
}

if (is_xml([Link].receipt_footer)){
[Link] = '';
receipt.footer_xml = render_xml([Link].receipt_footer);
} else {
[Link] = [Link].receipt_footer || '';
}

return receipt;
},
is_empty: function(){
return [Link] === 0;
},
generate_unique_id: function() {
// Generates a public identification number for the order.
// The generated number must be unique and sequential. They are made 12 digit
long
// to fit into EAN-13 barcodes, should it be needed

function zero_pad(num,size){
var s = ""+num;
while ([Link] < size) {
s = "0" + s;
}
return s;
}
return zero_pad([Link].pos_session.id,5) +'-'+
zero_pad([Link].pos_session.login_number,3) +'-'+
zero_pad(this.sequence_number,4);
},
get_name: function() {
return [Link];
},
assert_editable: function() {
if ([Link]) {
throw new Error('Finalized Order cannot be modified');
}
},
/* ---- Order Lines --- */
add_orderline: function(line){
this.assert_editable();
if([Link]){
[Link].remove_orderline(line);
}
 [Link] = this;
[Link](line);
this.select_orderline(this.get_last_orderline());
},
get_orderline: function(id){
var orderlines = [Link];
for(var i = 0; i < [Link]; i++){
if(orderlines[i].id === id){
return orderlines[i];
}
}
return null;
},
get_orderlines: function(){
return [Link];
},
get_last_orderline: function(){
return [Link]([Link] -1);
},
get_tip: function() {
var tip_product =
[Link].get_product_by_id([Link].tip_product_id[0]);
var lines = this.get_orderlines();
if (!tip_product) {
return 0;
} else {
for (var i = 0; i < [Link]; i++) {
if (lines[i].get_product() === tip_product) {
return lines[i].get_unit_price();
}
}
return 0;
}
},

initialize_validation_date: function () {
this.validation_date = new Date();
},

set_tip: function(tip) {
var tip_product =
[Link].get_product_by_id([Link].tip_product_id[0]);
var lines = this.get_orderlines();
if (tip_product) {
for (var i = 0; i < [Link]; i++) {
if (lines[i].get_product() === tip_product) {
lines[i].set_unit_price(tip);
return;
}
}
this.add_product(tip_product, {quantity: 1, price: tip });
}
},
remove_orderline: function( line ){
this.assert_editable();
[Link](line);
this.select_orderline(this.get_last_orderline());
},

fix_tax_included_price: function(line){
if(this.fiscal_position){
var unit_price = [Link];
var taxes = line.get_taxes();
 var mapped_included_taxes = [];
_(taxes).each(function(tax) {
var line_tax = line._map_tax_fiscal_position(tax);
if(tax.price_include && [Link] != line_tax.id){

mapped_included_taxes.push(tax);
}
})

unit_price = line.compute_all(mapped_included_taxes, unit_price, 1,

[Link], true).total_excluded;

line.set_unit_price(unit_price);
}

},

add_product: function(product, options){

if(this._printed){
[Link]();
return [Link].get_order().add_product(product, options);
}
this.assert_editable();
options = options || {};
var attr = [Link]([Link](product));
[Link] = [Link];
[Link] = this;
var line = new [Link]({}, {pos: [Link], order: this, product:
product});

if([Link] !== undefined){

line.set_quantity([Link]);
}

if([Link] !== undefined){

line.set_unit_price([Link]);
}

//To substract from the unit price the included taxes mapped by the fiscal
position
this.fix_tax_included_price(line);

if([Link] !== undefined){

line.set_discount([Link]);
}

if([Link] !== undefined){

for (var prop in [Link]) {
line[prop] = [Link][prop];
}
}

var last_orderline = this.get_last_orderline();

if( last_orderline && last_orderline.can_be_merged_with(line) && [Link]
!== false){
last_orderline.merge(line);
}else{
[Link](line);
}
this.select_orderline(this.get_last_orderline());

if(line.has_product_lot){
this.display_lot_popup();
 }
},
get_selected_orderline: function(){
return this.selected_orderline;
},
select_orderline: function(line){
if(line){
if(line !== this.selected_orderline){
if(this.selected_orderline){
this.selected_orderline.set_selected(false);
}
this.selected_orderline = line;
this.selected_orderline.set_selected(true);
}
}else{
this.selected_orderline = undefined;
}
},
deselect_orderline: function(){
if(this.selected_orderline){
this.selected_orderline.set_selected(false);
this.selected_orderline = undefined;
}
},

display_lot_popup: function() {
var order_line = this.get_selected_orderline();
if (order_line){
var pack_lot_lines = order_line.compute_lot_lines();
[Link].show_popup('packlotline', {
'title': _t('Lot/Serial Number(s) Required'),
'pack_lot_lines': pack_lot_lines,
'order': this
});
}
},

/* ---- Payment Lines --- */

add_paymentline: function(cashregister) {
this.assert_editable();
var newPaymentline = new [Link]({},{order: this,
cashregister:cashregister, pos: [Link]});
if([Link] !== 'cash' ||
[Link].iface_precompute_cash){
newPaymentline.set_amount( [Link](this.get_due(),0) );
}
[Link](newPaymentline);
this.select_paymentline(newPaymentline);

},
get_paymentlines: function(){
return [Link];
},
remove_paymentline: function(line){
this.assert_editable();
if(this.selected_paymentline === line){
this.select_paymentline(undefined);
}
[Link](line);
},
clean_empty_paymentlines: function() {
var lines = [Link];
var empty = [];
 for ( var i = 0; i < [Link]; i++) {
if (!lines[i].get_amount()) {
[Link](lines[i]);
}
}
for ( var i = 0; i < [Link]; i++) {
this.remove_paymentline(empty[i]);
}
},
select_paymentline: function(line){
if(line !== this.selected_paymentline){
if(this.selected_paymentline){
this.selected_paymentline.set_selected(false);
}
this.selected_paymentline = line;
if(this.selected_paymentline){
this.selected_paymentline.set_selected(true);
}
[Link]('change:selected_paymentline',this.selected_paymentline);
}
},
/* ---- Payment Status --- */
get_subtotal : function(){
return round_pr([Link]((function(sum, orderLine){
return sum + orderLine.get_display_price();
}), 0), [Link]);
},
get_total_with_tax: function() {
return this.get_total_without_tax() + this.get_total_tax();
},
get_total_without_tax: function() {
return round_pr([Link]((function(sum, orderLine) {
return sum + orderLine.get_price_without_tax();
}), 0), [Link]);
},
get_total_discount: function() {
return round_pr([Link]((function(sum, orderLine) {
return sum + (orderLine.get_unit_price() * (orderLine.get_discount()/100)
* orderLine.get_quantity());
}), 0), [Link]);
},
get_total_tax: function() {
return round_pr([Link]((function(sum, orderLine) {
return sum + orderLine.get_tax();
}), 0), [Link]);
},
get_total_paid: function() {
return round_pr([Link]((function(sum, paymentLine) {
return sum + paymentLine.get_amount();
}), 0), [Link]);
},
get_tax_details: function(){
var details = {};
var fulldetails = [];

[Link](function(line){
var ldetails = line.get_tax_details();
for(var id in ldetails){
if([Link](id)){
details[id] = (details[id] || 0) + ldetails[id];
}
}
});
 for(var id in details){
if([Link](id)){
[Link]({amount: details[id], tax: [Link].taxes_by_id[id],
name: [Link].taxes_by_id[id].name});
}
}

return fulldetails;
},
// Returns a total only for the orderlines with products belonging to the category
get_total_for_category_with_tax: function(categ_id){
var total = 0;
var self = this;

if (categ_id instanceof Array) {

for (var i = 0; i < categ_id.length; i++) {
total += this.get_total_for_category_with_tax(categ_id[i]);
}
return total;
}

[Link](function(line){
if ( [Link].category_contains(categ_id,[Link]) ) {
total += line.get_price_with_tax();
}
});

return total;
},
get_total_for_taxes: function(tax_id){
var total = 0;

if (!(tax_id instanceof Array)) {

tax_id = [tax_id];
}

var tax_set = {};

for (var i = 0; i < tax_id.length; i++) {

tax_set[tax_id[i]] = true;
}

[Link](function(line){
var taxes_ids = line.get_product().taxes_id;
for (var i = 0; i < taxes_ids.length; i++) {
if (tax_set[taxes_ids[i]]) {
total += line.get_price_with_tax();
return;
}
}
});

return total;
},
get_change: function(paymentline) {
if (!paymentline) {
var change = this.get_total_paid() - this.get_total_with_tax();
} else {
var change = -this.get_total_with_tax();
var lines = [Link];
for (var i = 0; i < [Link]; i++) {
change += lines[i].get_amount();
 if (lines[i] === paymentline) {
break;
}
}
}
return round_pr([Link](0,change), [Link]);
},
get_due: function(paymentline) {
if (!paymentline) {
var due = this.get_total_with_tax() - this.get_total_paid();
} else {
var due = this.get_total_with_tax();
var lines = [Link];
for (var i = 0; i < [Link]; i++) {
if (lines[i] === paymentline) {
break;
} else {
due -= lines[i].get_amount();
}
}
}
return round_pr([Link](0,due), [Link]);
},
is_paid: function(){
return this.get_due() === 0;
},
is_paid_with_cash: function(){
return !{
return [Link] === 'cash';
});
},
finalize: function(){
[Link]();
},
destroy: function(){
[Link](this,arguments);
[Link].remove_unpaid_order(this);
},
/* ---- Invoice --- */
set_to_invoice: function(to_invoice) {
this.assert_editable();
this.to_invoice = to_invoice;
},
is_to_invoice: function(){
return this.to_invoice;
},
/* ---- Client / Customer --- */
// the client related to the current order.
set_client: function(client){
this.assert_editable();
[Link]('client',client);
},
get_client: function(){
return [Link]('client');
},
get_client_name: function(){
var client = [Link]('client');
return client ? [Link] : "";
},
/* ---- Screen Status --- */
// the order also stores the screen status, as the PoS supports
// different active screens per order. This method is used to
// store the screen status.
 set_screen_data: function(key,value){
if([Link] === 2){
this.screen_data[key] = value;
}else if([Link] === 1){
for(var key in arguments[0]){
this.screen_data[key] = arguments[0][key];
}
}
},
//see set_screen_data
get_screen_data: function(key){
return this.screen_data[key];
},
});

var OrderCollection = [Link]({

model: [Link],
});

/*
The numpad handles both the choice of the property currently being modified
(quantity, price or discount) and the edition of the corresponding numeric value.
*/
[Link] = [Link]({
defaults: {
buffer: "0",
mode: "quantity"
},
appendNewChar: function(newChar) {
var oldBuffer;
oldBuffer = [Link]('buffer');
if (oldBuffer === '0') {
[Link]({
buffer: newChar
});
} else if (oldBuffer === '-0') {
[Link]({
buffer: "-" + newChar
});
} else {
[Link]({
buffer: ([Link]('buffer')) + newChar
});
}
[Link]('set_value',[Link]('buffer'));
},
deleteLastChar: function() {
if([Link]('buffer') === ""){
if([Link]('mode') === 'quantity'){
[Link]('set_value','remove');
}else{
[Link]('set_value',[Link]('buffer'));
}
}else{
var newBuffer = [Link]('buffer').slice(0,-1) || "";
[Link]({ buffer: newBuffer });
[Link]('set_value',[Link]('buffer'));
}
},
switchSign: function() {
var oldBuffer;
oldBuffer = [Link]('buffer');
[Link]({
 buffer: oldBuffer[0] === '-' ? [Link](1) : "-" + oldBuffer
});
[Link]('set_value',[Link]('buffer'));
},
changeMode: function(newMode) {
[Link]({
buffer: "0",
mode: newMode
});
},
reset: function() {
[Link]({
buffer: "0",
mode: "quantity"
});
},
resetValue: function(){
[Link]({buffer:'0'});
},
});

// exports = {
// PosModel: PosModel,
// NumpadState: NumpadState,
// load_fields: load_fields,
// load_models: load_models,
// Orderline: Orderline,
// Order: Order,
// };
return exports;

});
 POS Screens JS
[Link]('point_of_sale.screens', function (require) {
"use strict";
// This file contains the Screens definitions. Screens are the
// content of the right pane of the pos, containing the main functionalities.
//
// Screens must be defined and named in [Link] before use.
//
// Screens transitions are controlled by the Gui.
// gui.set_startup_screen() sets the screen displayed at startup
// gui.set_default_screen() sets the screen displayed for new orders
// gui.show_screen() shows a screen
// [Link]() goes to the previous screen
//
// Screen state is saved in the order. When a new order is selected,
// a screen is displayed based on the state previously saved in the order.
// this is also done in the Gui with:
// gui.show_saved_screen()
//
// All screens inherit from ScreenWidget. The only addition from the base widgets
// are show() and hide() which shows and hides the screen but are also used to
// bind and unbind actions on widgets and devices. The gui guarantees
// that only one screen is shown at the same time and that show() is called after all
// hide()s
//
// Each Screens must be independant from each other, and should have no
// persistent state outside the models. Screen state variables are reset at
// each screen display. A screen can be called with parameters, which are
// to be used for the duration of the screen only.

var PosBaseWidget = require('point_of_sale.BaseWidget');

var gui = require('point_of_sale.gui');
var models = require('point_of_sale.models');
var core = require('[Link]');
var Model = require('[Link]');
var utils = require('[Link]');
var formats = require('[Link]');

var QWeb = [Link];

var _t = core._t;

var round_pr = utils.round_precision;

/*--------------------------------------*\
| THE SCREEN WIDGET |
\*======================================*/

// The screen widget is the base class inherited

// by all screens.
var ScreenWidget = [Link]({

init: function(parent,options){
this._super(parent,options);
[Link] = false;
},

barcode_product_screen: 'products', //if defined, this screen will be

loaded when a product is scanned

// what happens when a product is scanned :

// it will add the product to the order and go to barcode_product_screen.
 barcode_product_action: function(code){
var self = this;
if ([Link].scan_product(code)) {
if (self.barcode_product_screen) {
[Link].show_screen(self.barcode_product_screen, null, null, true);
}
} else {
this.barcode_error_action(code);
}
},

// what happens when a cashier id barcode is scanned.

// the default behavior is the following :
// - if there's a user with a matching barcode, put it as the active 'cashier', go
to cashier mode, and return true
// - else : do nothing and return false. You probably want to extend this to show
and appropriate error popup...
barcode_cashier_action: function(code){
var users = [Link];
for(var i = 0, len = [Link]; i < len; i++){
if(users[i].barcode === [Link]){
[Link].set_cashier(users[i]);
[Link]();
return true;
}
}
this.barcode_error_action(code);
return false;
},

// what happens when a client id barcode is scanned.

// the default behavior is the following :
// - if there's a user with a matching barcode, put it as the active 'client' and
return true
// - else : return false.
barcode_client_action: function(code){
var partner = [Link].get_partner_by_barcode([Link]);
if(partner){
[Link].get_order().set_client(partner);
return true;
}
this.barcode_error_action(code);
return false;
},

// what happens when a discount barcode is scanned : the default behavior

// is to set the discount on the last order.
barcode_discount_action: function(code){
var last_orderline = [Link].get_order().get_last_orderline();
if(last_orderline){
last_orderline.set_discount([Link]);
}
},
// What happens when an invalid barcode is scanned : shows an error popup.
barcode_error_action: function(code) {
var show_code;
if ([Link] > 32) {
show_code = [Link](0,29)+'...';
} else {
show_code = [Link];
}
[Link].show_popup('error-barcode',show_code);
},
 // this method shows the screen and sets up all the widget related to this screen.
Extend this method
// if you want to alter the behavior of the screen.
show: function(){
var self = this;

[Link] = false;
if(this.$el){
this.$[Link]('oe_hidden');
}

[Link].barcode_reader.set_action_callback({
'cashier': _.bind(self.barcode_cashier_action, self),
'product': _.bind(self.barcode_product_action, self),
'weight': _.bind(self.barcode_product_action, self),
'price': _.bind(self.barcode_product_action, self),
'client' : _.bind(self.barcode_client_action, self),
'discount': _.bind(self.barcode_discount_action, self),
'error' : _.bind(self.barcode_error_action, self),
});
},

// this method is called when the screen is closed to make place for a new screen.
this is a good place
// to put your cleanup stuff as it is guaranteed that for each show() there is one
and only one close()
close: function(){
if([Link].barcode_reader){
[Link].barcode_reader.reset_action_callbacks();
}
},

// this methods hides the screen. It's not a good place to put your cleanup stuff
as it is called on the
// POS initialization.
hide: function(){
[Link] = true;
if(this.$el){
this.$[Link]('oe_hidden');
}
},

// we need this because some screens re-render themselves when they are hidden
// (due to some events, or magic, or both...) we must make sure they remain
hidden.
// the good solution would probably be to make them not re-render themselves when
they
// are hidden.
renderElement: function(){
this._super();
if([Link]){
if(this.$el){
this.$[Link]('oe_hidden');
}
}
},
});

/*--------------------------------------*\
| THE DOM CACHE |
\*======================================*/
// The Dom Cache is used by various screens to improve
// their performances when displaying many time the
// same piece of DOM.
//
// It is a simple map from string 'keys' to DOM Nodes.
//
// The cache empties itself based on usage frequency
// stats, so you may not always get back what
// you put in.

var DomCache = [Link]({

init: function(options){
options = options || {};
this.max_size = options.max_size || 2000;

[Link] = {};
this.access_time = {};
[Link] = 0;
},
cache_node: function(key,node){
var cached = [Link][key];
[Link][key] = node;
this.access_time[key] = new Date().getTime();
if(!cached){
[Link]++;
while([Link] >= this.max_size){
var oldest_key = null;
var oldest_time = new Date().getTime();
for(key in [Link]){
var time = this.access_time[key];
if(time <= oldest_time){
oldest_time = time;
oldest_key = key;
}
}
if(oldest_key){
delete [Link][oldest_key];
delete this.access_time[oldest_key];
}
[Link]--;
}
}
return node;
},
clear_node: function(key) {
var cached = [Link][key];
if (cached) {
delete [Link][key];
delete this.access_time[key];
[Link] --;
}
},
get_node: function(key){
var cached = [Link][key];
if(cached){
this.access_time[key] = new Date().getTime();
}
return cached;
},
});

/*--------------------------------------*\
| THE SCALE SCREEN |
\*======================================*/

// The scale screen displays the weight of

// a product on the electronic scale.

var ScaleScreenWidget = [Link]({

template:'ScaleScreenWidget',

next_screen: 'products',
previous_screen: 'products',

show: function(){
this._super();
var self = this;
var queue = [Link].proxy_queue;

this.set_weight(0);
[Link]();

this.hotkey_handler = function(event){
if([Link] === 13){
self.order_product();
[Link].show_screen(self.next_screen);
}else if([Link] === 27){
[Link].show_screen(self.previous_screen);
}
};

$('body').on('keypress',this.hotkey_handler);

this.$('.back').click(function(){
[Link].show_screen(self.previous_screen);
});

this.$('.next,.buy-product').click(function(){
[Link].show_screen(self.next_screen);
// add product *after* switching screen to scroll properly
self.order_product();
});

[Link](function(){
return [Link].scale_read().then(function(weight){
self.set_weight([Link]);
});
},{duration:150, repeat: true});

},
get_product: function(){
return [Link].get_current_screen_param('product');
},
order_product: function(){
[Link].get_order().add_product(this.get_product(),{ quantity: [Link]
});
},
get_product_name: function(){
var product = this.get_product();
return (product ? product.display_name : undefined) || 'Unnamed Product';
},
get_product_price: function(){
var product = this.get_product();
return (product ? [Link] : 0) || 0;
},
get_product_uom: function(){
 var product = this.get_product();

if(product){
return [Link].units_by_id[product.uom_id[0]].name;
}else{
return '';
}
},
set_weight: function(weight){
[Link] = weight;
this.$('.weight').text(this.get_product_weight_string());
this.$('.computed-price').text(this.get_computed_price_string());
},
get_product_weight_string: function(){
var product = this.get_product();
var defaultstr = ([Link] || 0).toFixed(3) + ' Kg';
if(!product || ![Link]){
return defaultstr;
}
var unit_id = product.uom_id;
if(!unit_id){
return defaultstr;
}
var unit = [Link].units_by_id[unit_id[0]];
var weight = round_pr([Link] || 0, [Link]);
var weightstr = [Link]([Link]([Link](1.0/[Link]) /
[Link](10) ));
weightstr += ' ' + [Link];
return weightstr;
},
get_computed_price_string: function(){
return this.format_currency(this.get_product_price() * [Link]);
},
close: function(){
this._super();
$('body').off('keypress',this.hotkey_handler);

[Link].proxy_queue.clear();
},
});
gui.define_screen({name: 'scale', widget: ScaleScreenWidget});

/*--------------------------------------*\
| THE PRODUCT SCREEN |
\*======================================*/

// The product screen contains the list of products,

// The category selector and the order display.
// It is the default screen for orders and the
// startup screen for shops.
//
// There product screens uses many sub-widgets,
// the code follows.

/* ------------ The Numpad ------------ */

// The numpad that edits the order lines.

var NumpadWidget = [Link]({

template:'NumpadWidget',
init: function(parent) {
this._super(parent);
 [Link] = new [Link]();
},
start: function() {
[Link]('change:mode', [Link], this);
[Link]();
this.$[Link]('.numpad-backspace').click(_.bind([Link],
this));
this.$[Link]('.numpad-minus').click(_.bind([Link], this));
this.$[Link]('.number-char').click(_.bind([Link], this));
this.$[Link]('.mode-button').click(_.bind([Link], this));
},
clickDeleteLastChar: function() {
return [Link]();
},
clickSwitchSign: function() {
return [Link]();
},
clickAppendNewChar: function(event) {
var newChar;
newChar = [Link] || [Link];
return [Link](newChar);
},
clickChangeMode: function(event) {
var newMode = [Link]['data-mode'].nodeValue;
return [Link](newMode);
},
changedMode: function() {
var mode = [Link]('mode');
$('.selected-mode').removeClass('selected-mode');
$(_.[Link]('.mode-button[data-mode="%s"]', mode),
this.$el).addClass('selected-mode');
},
});

/* ---------- The Action Pad ---------- */

// The action pad contains the payment button and the

// customer selection button

var ActionpadWidget = [Link]({

template: 'ActionpadWidget',
init: function(parent, options) {
var self = this;
this._super(parent, options);

[Link]('change:selectedClient', function() {
[Link]();
});
},
renderElement: function() {
var self = this;
this._super();
this.$('.pay').click(function(){
var order = [Link].get_order();
var has_valid_product_lot = _.every([Link],
function(line){
return line.has_valid_product_lot();
});
if(!has_valid_product_lot){
[Link].show_popup('confirm',{
'title': _t('Empty Serial/Lot Number'),
'body': _t('One or more product(s) required serial/lot number.'),
confirm: function(){
 [Link].show_screen('payment');
},
});
}else{
[Link].show_screen('payment');
}
});
this.$('.set-customer').click(function(){
[Link].show_screen('clientlist');
});
}
});

/* --------- The Order Widget --------- */

// Displays the current Order.

var OrderWidget = [Link]({

template:'OrderWidget',
init: function(parent, options) {
var self = this;
this._super(parent,options);

this.numpad_state = options.numpad_state;
this.numpad_state.reset();
this.numpad_state.bind('set_value', this.set_value, this);

[Link]('change:selectedOrder', this.change_selected_order, this);

this.line_click_handler = function(event){
self.click_line([Link], event);
};

if ([Link].get_order()) {
this.bind_order_events();
}

},
click_line: function(orderline, event) {
[Link].get_order().select_orderline(orderline);
this.numpad_state.reset();
},

set_value: function(val) {
var order = [Link].get_order();
if (order.get_selected_orderline()) {
var mode = this.numpad_state.get('mode');
if( mode === 'quantity'){
order.get_selected_orderline().set_quantity(val);
}else if( mode === 'discount'){
order.get_selected_orderline().set_discount(val);
}else if( mode === 'price'){
order.get_selected_orderline().set_unit_price(val);
}
}
},
change_selected_order: function() {
if ([Link].get_order()) {
this.bind_order_events();
this.numpad_state.reset();
[Link]();
}
},
orderline_add: function(){
this.numpad_state.reset();
[Link]('and_scroll_to_bottom');
},
orderline_remove: function(line){
this.remove_orderline(line);
this.numpad_state.reset();
this.update_summary();
},
orderline_change: function(line){
this.rerender_orderline(line);
this.update_summary();
},
bind_order_events: function() {
var order = [Link].get_order();
[Link]('change:client', this.update_summary, this);
[Link]('change:client', this.update_summary, this);
[Link]('change', this.update_summary, this);
[Link]('change', this.update_summary, this);

var lines = [Link];

[Link]('add', this.orderline_add, this);
[Link]('add', this.orderline_add, this);
[Link]('remove', this.orderline_remove, this);
[Link]('remove', this.orderline_remove, this);
[Link]('change', this.orderline_change, this);
[Link]('change', this.orderline_change, this);

},
render_orderline: function(orderline){
var el_str = [Link]('Orderline',{widget:this, line:orderline});
var el_node = [Link]('div');
el_node.innerHTML = _.[Link](el_str);
el_node = el_node.childNodes[0];
el_node.orderline = orderline;
el_node.addEventListener('click',this.line_click_handler);
var el_lot_icon = el_node.querySelector('.line-lot-icon');
if(el_lot_icon){
el_lot_icon.addEventListener('click', (function() {
this.show_product_lot(orderline);
}.bind(this)));
}

[Link] = el_node;
return el_node;
},
remove_orderline: function(order_line){
if([Link].get_order().get_orderlines().length === 0){
[Link]();
}else{
order_line.[Link](order_line.node);
}
},
rerender_orderline: function(order_line){
var node = order_line.node;
var replacement_line = this.render_orderline(order_line);
[Link](replacement_line,node);
},
// overriding the openerp framework replace method for performance reasons
replace: function($target){
[Link]();
var target = $target[0];
 [Link]([Link],target);
},
renderElement: function(scrollbottom){
var order = [Link].get_order();
if (!order) {
return;
}
var orderlines = order.get_orderlines();

var el_str = [Link]('OrderWidget',{widget:this, order:order,

orderlines:orderlines});

var el_node = [Link]('div');

el_node.innerHTML = _.[Link](el_str);
el_node = el_node.childNodes[0];

var list_container = el_node.querySelector('.orderlines');

for(var i = 0, len = [Link]; i < len; i++){
var orderline = this.render_orderline(orderlines[i]);
list_container.appendChild(orderline);
}

if([Link] && [Link]){

[Link](el_node,[Link]);
}
[Link] = el_node;
this.update_summary();

if(scrollbottom){
[Link]('.order-scroller').scrollTop = 100 *
[Link];
}
},
update_summary: function(){
var order = [Link].get_order();
if (!order.get_orderlines().length) {
return;
}

var total = order ? order.get_total_with_tax() : 0;

var taxes = order ? total - order.get_total_without_tax() : 0;

[Link]('.summary .total > .value').textContent =

this.format_currency(total);
[Link]('.summary .total .subentry .value').textContent =
this.format_currency(taxes);
},
show_product_lot: function(orderline){
[Link].get_order().select_orderline(orderline);
var order = [Link].get_order();
order.display_lot_popup();
},
});

/* ------ The Product Categories ------ */

// Display and navigate the product categories.

// Also handles searches.
// - set_category() to change the displayed category
// - reset_category() to go to the root category
// - perform_search() to search for products
// - clear_search() does what it says.
var ProductCategoriesWidget = [Link]({
template: 'ProductCategoriesWidget',
init: function(parent, options){
var self = this;
this._super(parent,options);
this.product_type = options.product_type || 'all'; // 'all' | 'weightable'
[Link] = [Link] || false;
[Link] = [Link].root_category;
[Link] = [];
[Link] = [];
this.product_list_widget = options.product_list_widget || null;
this.category_cache = new DomCache();
this.start_categ_id = [Link].iface_start_categ_id ?
[Link].iface_start_categ_id[0] : 0;
this.set_category([Link].get_category_by_id(this.start_categ_id));

this.switch_category_handler = function(event){

self.set_category([Link].get_category_by_id(Number([Link])));
[Link]();
};

this.clear_search_handler = function(event){
self.clear_search();
};

var search_timeout = null;

this.search_handler = function(event){
if([Link] == "keypress" || [Link] === 46 || [Link] ===
8){
clearTimeout(search_timeout);

var searchbox = this;

search_timeout = setTimeout(function(){
self.perform_search([Link], [Link], [Link]
=== 13);
},70);
}
};
},

// changes the category. if undefined, sets to root category

set_category : function(category){
var db = [Link];
if(!category){
[Link] = db.get_category_by_id(db.root_category_id);
}else{
[Link] = category;
}
[Link] = [];
var ancestors_ids = db.get_category_ancestors_ids([Link]);
for(var i = 1; i < ancestors_ids.length; i++){
[Link](db.get_category_by_id(ancestors_ids[i]));
}
if([Link] !== db.root_category_id){
[Link]([Link]);
}
[Link] =
db.get_category_by_id(db.get_category_childs_ids([Link]));
},
 get_image_url: function(category){
return [Link] +
'/web/image?model=[Link]&field=image_medium&id='+[Link];
},

render_category: function( category, with_image ){

var cached = this.category_cache.get_node([Link]);
if(!cached){
if(with_image){
var image_url = this.get_image_url(category);
var category_html = [Link]('CategoryButton',{
widget: this,
category: category,
image_url: this.get_image_url(category),
});
category_html = _.[Link](category_html);
var category_node = [Link]('div');
category_node.innerHTML = category_html;
category_node = category_node.childNodes[0];
}else{
var category_html = [Link]('CategorySimpleButton',{
widget: this,
category: category,
});
category_html = _.[Link](category_html);
var category_node = [Link]('div');
category_node.innerHTML = category_html;
category_node = category_node.childNodes[0];
}
this.category_cache.cache_node([Link],category_node);
return category_node;
}
return cached;
},

replace: function($target){
[Link]();
var target = $target[0];
[Link]([Link],target);
},

renderElement: function(){

var el_str = [Link]([Link], {widget: this});

var el_node = [Link]('div');

el_node.innerHTML = el_str;
el_node = el_node.childNodes[1];

if([Link] && [Link]){

[Link](el_node,[Link]);
}

[Link] = el_node;

var withpics = [Link].iface_display_categ_images;

var list_container = el_node.querySelector('.category-list');

if (list_container) {
if (!withpics) {
list_container.[Link]('simple');
} else {
list_container.[Link]('simple');
 }
for(var i = 0, len = [Link]; i < len; i++){

list_container.appendChild(this.render_category([Link][i],withpics));
}
}

var buttons = el_node.querySelectorAll('.js-category-switch');

for(var i = 0; i < [Link]; i++){
buttons[i].addEventListener('click',this.switch_category_handler);
}

var products = [Link].get_product_by_category([Link]);

this.product_list_widget.set_product_list(products); // FIXME: this should be
moved elsewhere ...

[Link]('.searchbox
input').addEventListener('keypress',this.search_handler);

[Link]('.searchbox
input').addEventListener('keydown',this.search_handler);

[Link]('.search-
clear').addEventListener('click',this.clear_search_handler);

if([Link].iface_vkeyboard && [Link]){

[Link]($([Link]('.searchbox
input')));
}
},

// resets the current category to the root category

reset_category: function(){
this.set_category([Link].get_category_by_id(this.start_categ_id));
[Link]();
},

// empties the content of the search box

clear_search: function(){
var products = [Link].get_product_by_category([Link]);
this.product_list_widget.set_product_list(products);
var input = [Link]('.searchbox input');
[Link] = '';
[Link]();
},
perform_search: function(category, query, buy_result){
var products;
if(query){
products = [Link].search_product_in_category([Link],query);
if(buy_result && [Link] === 1){
[Link].get_order().add_product(products[0]);
this.clear_search();
}else{
this.product_list_widget.set_product_list(products);
}
}else{
products = [Link].get_product_by_category([Link]);
this.product_list_widget.set_product_list(products);
}
},

});
/* --------- The Product List --------- */

// Display the list of products.

// - change the list with .set_product_list()
// - click_product_action(), passed as an option, tells
// what to do when a product is clicked.

var ProductListWidget = [Link]({

template:'ProductListWidget',
init: function(parent, options) {
var self = this;
this._super(parent,options);
[Link] = [Link];
[Link] = [];
[Link] = [Link] || 0;
this.show_scale = options.show_scale || false;
this.next_screen = options.next_screen || false;

this.click_product_handler = function(){
var product = [Link].get_product_by_id([Link]);
options.click_product_action(product);
};

this.product_list = options.product_list || [];

this.product_cache = new DomCache();
},
set_product_list: function(product_list){
this.product_list = product_list;
[Link]();
},
get_product_image_url: function(product){
return [Link] +
'/web/image?model=[Link]&field=image_medium&id='+[Link];
},
replace: function($target){
[Link]();
var target = $target[0];
[Link]([Link],target);
},

render_product: function(product){
var cached = this.product_cache.get_node([Link]);
if(!cached){
var image_url = this.get_product_image_url(product);
var product_html = [Link]('Product',{
widget: this,
product: product,
image_url: this.get_product_image_url(product),
});
var product_node = [Link]('div');
product_node.innerHTML = product_html;
product_node = product_node.childNodes[1];
this.product_cache.cache_node([Link],product_node);
return product_node;
}
return cached;
},

renderElement: function() {
var el_str = [Link]([Link], {widget: this});
var el_node = [Link]('div');
el_node.innerHTML = el_str;
el_node = el_node.childNodes[1];
 if([Link] && [Link]){
[Link](el_node,[Link]);
}
[Link] = el_node;

var list_container = el_node.querySelector('.product-list');

for(var i = 0, len = this.product_list.length; i < len; i++){
var product_node = this.render_product(this.product_list[i]);
product_node.addEventListener('click',this.click_product_handler);
list_container.appendChild(product_node);
}
},
});

/* -------- The Action Buttons -------- */

// Above the numpad and the actionpad, buttons

// for extra actions and controls by point of
// sale extensions modules.

var action_button_classes = [];

var define_action_button = function(classe, options){
options = options || {};

var classes = action_button_classes;

var index = [Link];
var i;

if ([Link]) {
for (i = 0; i < [Link]; i++) {
if (classes[i].name === [Link]) {
index = i + 1;
}
}
} else if ([Link]) {
for (i = 0; i < [Link]; i++) {
if (classes[i].name === [Link]) {
index = i;
break;
}
}
}
[Link](i,0,classe);
};

var ActionButtonWidget = [Link]({

template: 'ActionButtonWidget',
label: _t('Button'),
renderElement: function(){
var self = this;
this._super();
this.$[Link](function(){
self.button_click();
});
},
button_click: function(){},
highlight: function(highlight){
this.$[Link]('highlight',!!highlight);
},
// alternative highlight color
altlight: function(altlight){
this.$[Link]('altlight',!!altlight);
 },
});

/* -------- The Product Screen -------- */

var ProductScreenWidget = [Link]({

template:'ProductScreenWidget',

start: function(){

var self = this;

[Link] = new ActionpadWidget(this,{});

[Link](this.$('.placeholder-ActionpadWidget'));

[Link] = new NumpadWidget(this,{});

[Link](this.$('.placeholder-NumpadWidget'));

this.order_widget = new OrderWidget(this,{

numpad_state: [Link],
});
this.order_widget.replace(this.$('.placeholder-OrderWidget'));

this.product_list_widget = new ProductListWidget(this,{

click_product_action: function(product){ self.click_product(product); },
product_list: [Link].get_product_by_category(0)
});
this.product_list_widget.replace(this.$('.placeholder-ProductListWidget'));

this.product_categories_widget = new ProductCategoriesWidget(this,{

product_list_widget: this.product_list_widget,
});
this.product_categories_widget.replace(this.$('.placeholder-
ProductCategoriesWidget'));

this.action_buttons = {};
var classes = action_button_classes;
for (var i = 0; i < [Link]; i++) {
var classe = classes[i];
if ( ![Link] || [Link](this) ) {
var widget = new [Link](this,{});
[Link](this.$('.control-buttons'));
this.action_buttons[[Link]] = widget;
}
}
if (_.size(this.action_buttons)) {
this.$('.control-buttons').removeClass('oe_hidden');
}
},

click_product: function(product) {
if(product.to_weight && [Link].iface_electronic_scale){
[Link].show_screen('scale',{product: product});
}else{
[Link].get_order().add_product(product);
}
},

show: function(reset){
this._super();
if (reset) {
this.product_categories_widget.reset_category();
[Link]();
 }
},

close: function(){
this._super();
if([Link].iface_vkeyboard && [Link]){
[Link]();
}
},
});
gui.define_screen({name:'products', widget: ProductScreenWidget});

/*--------------------------------------*\
| THE CLIENT LIST |
\*======================================*/

// The clientlist displays the list of customer,

// and allows the cashier to create, edit and assign
// customers.

var ClientListScreenWidget = [Link]({

template: 'ClientListScreenWidget',

init: function(parent, options){

this._super(parent, options);
this.partner_cache = new DomCache();
},

auto_back: true,

show: function(){
var self = this;
this._super();

[Link]();
this.details_visible = false;
this.old_client = [Link].get_order().get_client();

this.$('.back').click(function(){
[Link]();
});

this.$('.next').click(function(){
self.save_changes();
[Link](); // FIXME HUH ?
});

this.$('.new-customer').click(function(){
self.display_client_details('edit',{
'country_id': [Link].country_id,
});
});

var partners = [Link].get_partners_sorted(1000);

this.render_list(partners);

this.reload_partners();

if( this.old_client ){
this.display_client_details('show',this.old_client,0);
}

this.$('.client-list-contents').delegate('.client-
line','click',function(event){
self.line_select(event,$(this),parseInt($(this).data('id')));
});

var search_timeout = null;

if([Link].iface_vkeyboard && [Link]){

[Link](this.$('.searchbox input'));
}

this.$('.searchbox input').on('keypress',function(event){
clearTimeout(search_timeout);

var query = [Link];

search_timeout = setTimeout(function(){
self.perform_search(query,[Link] === 13);
},70);
});

this.$('.searchbox .search-clear').click(function(){
self.clear_search();
});
},
hide: function () {
this._super();
this.new_client = null;
},
barcode_client_action: function(code){
if (this.editing_client) {
this.$('.[Link]').val([Link]);
} else if ([Link].get_partner_by_barcode([Link])) {
var partner = [Link].get_partner_by_barcode([Link]);
this.new_client = partner;
this.display_client_details('show', partner);
}
},
perform_search: function(query, associate_result){
var customers;
if(query){
customers = [Link].search_partner(query);
this.display_client_details('hide');
if ( associate_result && [Link] === 1){
this.new_client = customers[0];
this.save_changes();
[Link]();
}
this.render_list(customers);
}else{
customers = [Link].get_partners_sorted();
this.render_list(customers);
}
},
clear_search: function(){
var customers = [Link].get_partners_sorted(1000);
this.render_list(customers);
this.$('.searchbox input')[0].value = '';
this.$('.searchbox input').focus();
},
render_list: function(partners){
var contents = this.$el[0].querySelector('.client-list-contents');
[Link] = "";
for(var i = 0, len = [Link]([Link],1000); i < len; i++){
 var partner = partners[i];
var clientline = this.partner_cache.get_node([Link]);
if(!clientline){
var clientline_html = [Link]('ClientLine',{widget: this,
partner:partners[i]});
var clientline = [Link]('tbody');
[Link] = clientline_html;
clientline = [Link][1];
this.partner_cache.cache_node([Link],clientline);
}
if( partner === this.old_client ){
[Link]('highlight');
}else{
[Link]('highlight');
}
[Link](clientline);
}
},
save_changes: function(){
var self = this;
var order = [Link].get_order();
if( this.has_client_changed() ){
if ( this.new_client ) {
order.fiscal_position = _.find([Link].fiscal_positions, function
(fp) {
return [Link] === self.new_client.property_account_position_id[0];
});
} else {
order.fiscal_position = undefined;
}

order.set_client(this.new_client);
}
},
has_client_changed: function(){
if( this.old_client && this.new_client ){
return this.old_client.id !== this.new_client.id;
}else{
return !!this.old_client !== !!this.new_client;
}
},
toggle_save_button: function(){
var $button = this.$('.[Link]');
if (this.editing_client) {
$[Link]('oe_hidden');
return;
} else if( this.new_client ){
if( !this.old_client){
$[Link](_t('Set Customer'));
}else{
$[Link](_t('Change Customer'));
}
}else{
$[Link](_t('Deselect Customer'));
}
$[Link]('oe_hidden',!this.has_client_changed());
},
line_select: function(event,$line,id){
var partner = [Link].get_partner_by_id(id);
this.$('.client-list .lowlight').removeClass('lowlight');
if ( $[Link]('highlight') ){
$[Link]('highlight');
$[Link]('lowlight');
 this.display_client_details('hide',partner);
this.new_client = null;
this.toggle_save_button();
}else{
this.$('.client-list .highlight').removeClass('highlight');
$[Link]('highlight');
var y = [Link] - $[Link]().offset().top;
this.display_client_details('show',partner,y);
this.new_client = partner;
this.toggle_save_button();
}
},
partner_icon_url: function(id){
return '/web/image?model=[Link]&id='+id+'&field=image_small';
},

// ui handle for the 'edit selected customer' action

edit_client_details: function(partner) {
this.display_client_details('edit',partner);
},

// ui handle for the 'cancel customer edit changes' action

undo_client_details: function(partner) {
if (![Link]) {
this.display_client_details('hide');
} else {
this.display_client_details('show',partner);
}
},

// what happens when we save the changes on the client edit form -> we fetch the
fields, sanitize them,
// send them to the backend for update, and call saved_client_details() when the
server tells us the
// save was successfull.
save_client_details: function(partner) {
var self = this;

var fields = {};

this.$('.client-details-contents .detail').each(function(idx,el){
fields[[Link]] = [Link] || false;
});

if (![Link]) {
[Link].show_popup('error',_t('A Customer Name Is Required'));
return;
}

if (this.uploaded_picture) {
[Link] = this.uploaded_picture;
}

[Link] = [Link] || false;

fields.country_id = fields.country_id || false;

new
Model('[Link]').call('create_from_ui',[fields]).then(function(partner_id){
self.saved_client_details(partner_id);
},function(err,event){
[Link]();
[Link].show_popup('error',{
'title': _t('Error: Could not Save Changes'),
'body': _t('Your Internet connection is probably down.'),
 });
});
},

// what happens when we've just pushed modifications for a partner of id

partner_id
saved_client_details: function(partner_id){
var self = this;
this.reload_partners().then(function(){
var partner = [Link].get_partner_by_id(partner_id);
if (partner) {
self.new_client = partner;
self.toggle_save_button();
self.display_client_details('show',partner);
} else {
// should never happen, because create_from_ui must return the id of
the partner it
// has created, and reload_partner() must have loaded the newly
created partner.
self.display_client_details('hide');
}
});
},

// resizes an image, keeping the aspect ratio intact,

// the resize is useful to avoid sending 12Mpixels jpegs
// over a wireless connection.
resize_image_to_dataurl: function(img, maxwidth, maxheight, callback){
[Link] = function(){
var canvas = [Link]('canvas');
var ctx = [Link]('2d');
var ratio = 1;

if ([Link] > maxwidth) {

ratio = maxwidth / [Link];
}
if ([Link] * ratio > maxheight) {
ratio = maxheight / [Link];
}
var width = [Link]([Link] * ratio);
var height = [Link]([Link] * ratio);

[Link] = width;
[Link] = height;
[Link](img,0,0,width,height);

var dataurl = [Link]();

callback(dataurl);
};
},

// Loads and resizes a File that contains an image.

// callback gets a dataurl in case of success.
load_image_file: function(file, callback){
var self = this;
if () {
[Link].show_popup('error',{
title: _t('Unsupported File Format'),
body: _t('Only web-compatible Image formats such as .png or .jpeg are
supported'),
});
return;
}
 var reader = new FileReader();
[Link] = function(event){
var dataurl = [Link];
var img = new Image();
[Link] = dataurl;
self.resize_image_to_dataurl(img,800,600,callback);
};
[Link] = function(){
[Link].show_popup('error',{
title :_t('Could Not Read Image'),
body :_t('The provided file could not be read due to an unknown
error'),
});
};
[Link](file);
},

// This fetches partner changes on the server, and in case of changes,

// rerenders the affected views
reload_partners: function(){
var self = this;
return [Link].load_new_partners().then(function(){
self.render_list([Link].get_partners_sorted(1000));

// update the currently assigned client if it has been changed in db.

var curr_client = [Link].get_order().get_client();
if (curr_client) {

[Link].get_order().set_client([Link].get_partner_by_id(curr_client.id));
}
});
},

// Shows,hides or edit the customer details box :

// visibility: 'show', 'hide' or 'edit'
// partner: the partner object to show or edit
// clickpos: the height of the click on the list (in pixel), used
// to maintain consistent scroll.
display_client_details: function(visibility,partner,clickpos){
var self = this;
var contents = this.$('.client-details-contents');
var parent = this.$('.client-list').parent();
var scroll = [Link]();
var height = [Link]();

[Link]('click','.[Link]');
[Link]('click','.[Link]');
[Link]('click','.[Link]');
[Link]('click','.[Link]',function(){
self.edit_client_details(partner); });
[Link]('click','.[Link]',function(){
self.save_client_details(partner); });
[Link]('click','.[Link]',function(){
self.undo_client_details(partner); });
this.editing_client = false;
this.uploaded_picture = null;

if(visibility === 'show'){

[Link]();

[Link]($([Link]('ClientDetails',{widget:this,partner:partner})));
 var new_height = [Link]();

if(!this.details_visible){
// resize client list to take into account client details
[Link]('-=' + new_height);

if(clickpos < scroll + new_height + 20 ){

[Link]( clickpos - 20 );
}else{
[Link]([Link]() + new_height);
}
}else{
[Link]([Link]() - height + new_height);
}

this.details_visible = true;
this.toggle_save_button();
} else if (visibility === 'edit') {
this.editing_client = true;
[Link]();

[Link]($([Link]('ClientDetailsEdit',{widget:this,partner:partner})));
this.toggle_save_button();

// Browsers attempt to scroll invisible input elements

// into view (eg. when hidden behind keyboard). They don't
// seem to take into account that some elements are not
// scrollable.
[Link]('input').blur(function() {
setTimeout(function() {
self.$('.window').scrollTop(0);
}, 0);
});

[Link]('.image-uploader').on('change',function(event){
self.load_image_file([Link][0],function(res){
if (res) {
[Link]('.client-picture img, .client-picture
.fa').remove();
[Link]('.client-picture').append("<img
src='"+res+"'>");
[Link]('.[Link]').remove();
self.uploaded_picture = res;
}
});
});
} else if (visibility === 'hide') {
[Link]();
[Link]('100%');
if( height > scroll ){
[Link]({height:height+'px'});
[Link]({height:0},400,function(){
[Link]({height:''});
});
}else{
[Link]( [Link]() - height);
}
this.details_visible = false;
this.toggle_save_button();
}
},
close: function(){
this._super();
 },
});
gui.define_screen({name:'clientlist', widget: ClientListScreenWidget});

/*--------------------------------------*\
| THE RECEIPT SCREEN |
\*======================================*/

// The receipt screen displays the order's

// receipt and allows it to be printed in a web browser.
// The receipt screen is not shown if the point of sale
// is set up to print with the proxy. Altough it could
// be useful to do so...

var ReceiptScreenWidget = [Link]({

template: 'ReceiptScreenWidget',
show: function(){
this._super();
var self = this;

this.render_change();
this.render_receipt();
this.handle_auto_print();
},
handle_auto_print: function() {
if (this.should_auto_print()) {
[Link]();
if (this.should_close_immediately()){
this.click_next();
}
} else {
this.lock_screen(false);
}
},
should_auto_print: function() {
return [Link].iface_print_auto && ![Link].get_order()._printed;
},
should_close_immediately: function() {
return [Link].iface_print_via_proxy &&
[Link].iface_print_skip_screen;
},
lock_screen: function(locked) {
this._locked = locked;
if (locked) {
this.$('.next').removeClass('highlight');
} else {
this.$('.next').addClass('highlight');
}
},
print_web: function() {
[Link]();
[Link].get_order()._printed = true;
},
print_xml: function() {
var env = {
widget: this,
order: [Link].get_order(),
receipt: [Link].get_order().export_for_printing(),
paymentlines: [Link].get_order().get_paymentlines()
};
var receipt = [Link]('XmlReceipt',env);

[Link].print_receipt(receipt);
 [Link].get_order()._printed = true;
},
print: function() {
var self = this;

if (![Link].iface_print_via_proxy) { // browser (html) printing

// The problem is that in chrome the print() is asynchronous and doesn't

// execute until all rpc are finished. So it conflicts with the rpc used
// to send the orders to the backend, and the user is able to go to the
next
// screen before the printing dialog is opened. The problem is that what's
// printed is whatever is in the page when the dialog is opened and not
when it's called,
// and so you end up printing the product list instead of the receipt...
//
// Fixing this would need a re-architecturing
// of the code to postpone sending of orders after printing.
//
// But since the print dialog also blocks the other asynchronous calls,
the
// button enabling in the setTimeout() is blocked until the printing
dialog is
// closed. But the timeout has to be big enough or else it doesn't work
// 1 seconds is the same as the default timeout for sending orders and so
the dialog
// should have appeared before the timeout... so yeah that's not ultra
reliable.

this.lock_screen(true);

setTimeout(function(){
self.lock_screen(false);
}, 1000);

this.print_web();
} else { // proxy (xml) printing
this.print_xml();
this.lock_screen(false);
}
},
click_next: function() {
[Link].get_order().finalize();
},
click_back: function() {
// Placeholder method for ReceiptScreen extensions that
// can go back ...
},
renderElement: function() {
var self = this;
this._super();
this.$('.next').click(function(){
if (!self._locked) {
self.click_next();
}
});
this.$('.back').click(function(){
if (!self._locked) {
self.click_back();
}
});
this.$('.[Link]').click(function(){
if (!self._locked) {
 [Link]();
}
});
},
render_change: function() {
this.$('.change-
value').html(this.format_currency([Link].get_order().get_change()));
},
render_receipt: function() {
var order = [Link].get_order();
this.$('.pos-receipt-container').html([Link]('PosTicket',{
widget:this,
order: order,
receipt: order.export_for_printing(),
orderlines: order.get_orderlines(),
paymentlines: order.get_paymentlines(),
}));
},
});
gui.define_screen({name:'receipt', widget: ReceiptScreenWidget});

/*--------------------------------------*\
| THE PAYMENT SCREEN |
\*======================================*/

// The Payment Screen handles the payments, and

// it is unfortunately quite complicated.

var PaymentScreenWidget = [Link]({

template: 'PaymentScreenWidget',
back_screen: 'product',
init: function(parent, options) {
var self = this;
this._super(parent, options);

[Link]('change:selectedOrder',function(){
[Link]();
this.watch_order_changes();
},this);
this.watch_order_changes();

[Link] = "";
[Link] = true;
this.decimal_point = _t.[Link].decimal_point;

// This is a keydown handler that prevents backspace from

// doing a back navigation. It also makes sure that keys that
// do not generate a keypress in Chrom{e,ium} (eg. delete,
// backspace, ...) get passed to the keypress handler.
this.keyboard_keydown_handler = function(event){
if ([Link] === 8 || [Link] === 46) { // Backspace and Delete
[Link]();

// These do not generate keypress events in

// Chrom{e,ium}. Even if they did, we just called
// preventDefault which will cancel any keypress that
// would normally follow. So we call keyboard_handler
// explicitly with this keydown event.
self.keyboard_handler(event);
}
};

// This keyboard handler listens for keypress events. It is

 // also called explicitly to handle some keydown events that
// do not generate keypress events.
this.keyboard_handler = function(event){
var key = '';

if ([Link] === "keypress") {

if ([Link] === 13) { // Enter
self.validate_order();
} else if ( [Link] === 190 || // Dot
[Link] === 110 || // Decimal point (numpad)
[Link] === 188 || // Comma
[Link] === 46 ) { // Numpad dot
key = self.decimal_point;
} else if ([Link] >= 48 && [Link] <= 57) { // Numbers
key = '' + ([Link] - 48);
} else if ([Link] === 45) { // Minus
key = '-';
} else if ([Link] === 43) { // Plus
key = '+';
}
} else { // keyup/keydown
if ([Link] === 46) { // Delete
key = 'CLEAR';
} else if ([Link] === 8) { // Backspace
key = 'BACKSPACE';
}
}

self.payment_input(key);
[Link]();
};

[Link]('change:selectedClient', function() {
self.customer_changed();
}, this);
},
// resets the current input buffer
reset_input: function(){
var line = [Link].get_order().selected_paymentline;
[Link] = true;
if (line) {
[Link] = this.format_currency_no_symbol(line.get_amount());
} else {
[Link] = "";
}
},
// handle both keyboard and numpad input. Accepts
// a string that represents the key pressed.
payment_input: function(input) {
var newbuf = [Link].numpad_input([Link], input, {'firstinput':
[Link]});

[Link] = ([Link] === 0);

// popup block inputs to prevent sneak editing.

if ([Link].has_popup()) {
return;
}

if (newbuf !== [Link]) {

[Link] = newbuf;
var order = [Link].get_order();
if (order.selected_paymentline) {
 var amount = [Link];

if ([Link] !== "-") {

amount = formats.parse_value([Link], {type: "float"},
0.0);
}

order.selected_paymentline.set_amount(amount);
this.order_changes();
this.render_paymentlines();
this.$('.[Link]
.edit').text(this.format_currency_no_symbol(amount));
}
}
},
click_numpad: function(button) {
var paymentlines = [Link].get_order().get_paymentlines();
var open_paymentline = false;

for (var i = 0; i < [Link]; i++) {

if (! paymentlines[i].paid) {
open_paymentline = true;
}
}

if (! open_paymentline) {
[Link].get_order().add_paymentline( [Link][0]);
this.render_paymentlines();
}

this.payment_input([Link]('action'));
},
render_numpad: function() {
var self = this;
var numpad = $([Link]('PaymentScreen-Numpad', { widget:this }));
[Link]('click','button',function(){
self.click_numpad($(this));
});
return numpad;
},
click_delete_paymentline: function(cid){
var lines = [Link].get_order().get_paymentlines();
for ( var i = 0; i < [Link]; i++ ) {
if (lines[i].cid === cid) {
[Link].get_order().remove_paymentline(lines[i]);
this.reset_input();
this.render_paymentlines();
return;
}
}
},
click_paymentline: function(cid){
var lines = [Link].get_order().get_paymentlines();
for ( var i = 0; i < [Link]; i++ ) {
if (lines[i].cid === cid) {
[Link].get_order().select_paymentline(lines[i]);
this.reset_input();
this.render_paymentlines();
return;
}
}
},
render_paymentlines: function() {
 var self = this;
var order = [Link].get_order();
if (!order) {
return;
}

var lines = order.get_paymentlines();

var due = order.get_due();
var extradue = 0;
if (due && [Link] && due !== order.get_due(lines[[Link]-1])) {
extradue = due;
}

this.$('.paymentlines-container').empty();
var lines = $([Link]('PaymentScreen-Paymentlines', {
widget: this,
order: order,
paymentlines: lines,
extradue: extradue,
}));

[Link]('click','.delete-button',function(){
self.click_delete_paymentline($(this).data('cid'));
});

[Link]('click','.paymentline',function(){
self.click_paymentline($(this).data('cid'));
});

[Link](this.$('.paymentlines-container'));
},
click_paymentmethods: function(id) {
var cashregister = null;
for ( var i = 0; i < [Link]; i++ ) {
if ( [Link][i].journal_id[0] === id ){
cashregister = [Link][i];
break;
}
}
[Link].get_order().add_paymentline( cashregister );
this.reset_input();
this.render_paymentlines();
},
render_paymentmethods: function() {
var self = this;
var methods = $([Link]('PaymentScreen-Paymentmethods', { widget:this }));
[Link]('click','.paymentmethod',function(){
self.click_paymentmethods($(this).data('id'));
});
return methods;
},
click_invoice: function(){
var order = [Link].get_order();
order.set_to_invoice(!order.is_to_invoice());
if (order.is_to_invoice()) {
this.$('.js_invoice').addClass('highlight');
} else {
this.$('.js_invoice').removeClass('highlight');
}
},
click_tip: function(){
var self = this;
 var order = [Link].get_order();
var tip = order.get_tip();
var change = order.get_change();
var value = tip;

if (tip === 0 && change > 0 ) {

value = change;
}

[Link].show_popup('number',{
'title': tip ? _t('Change Tip') : _t('Add Tip'),
'value': self.format_currency_no_symbol(value),
'confirm': function(value) {
order.set_tip(formats.parse_value(value, {type: "float"}, 0));
self.order_changes();
self.render_paymentlines();
}
});
},
customer_changed: function() {
var client = [Link].get_client();
this.$('.js_customer_name').text( client ? [Link] : _t('Customer') );
},
click_set_customer: function(){
[Link].show_screen('clientlist');
},
click_back: function(){
[Link].show_screen('products');
},
renderElement: function() {
var self = this;
this._super();

var numpad = this.render_numpad();

[Link](this.$('.payment-numpad'));

var methods = this.render_paymentmethods();

[Link](this.$('.paymentmethods-container'));

this.render_paymentlines();

this.$('.back').click(function(){
self.click_back();
});

this.$('.next').click(function(){
self.validate_order();
});

this.$('.js_set_customer').click(function(){
self.click_set_customer();
});

this.$('.js_tip').click(function(){
self.click_tip();
});
this.$('.js_invoice').click(function(){
self.click_invoice();
});

this.$('.js_cashdrawer').click(function(){
[Link].open_cashbox();
});
 },
show: function(){
[Link].get_order().clean_empty_paymentlines();
this.reset_input();
this.render_paymentlines();
this.order_changes();
[Link]('keypress',this.keyboard_handler);

[Link]('keydown',this.keyboard_keydown_handler);
this._super();
},
hide: function(){
[Link]('keypress',this.keyboard_handler);

[Link]('keydown',this.keyboard_keydown_handler);
this._super();
},
// sets up listeners to watch for order changes
watch_order_changes: function() {
var self = this;
var order = [Link].get_order();
if (!order) {
return;
}
if(this.old_order){
this.old_order.unbind(null,null,this);
}
[Link]('all',function(){
self.order_changes();
});
this.old_order = order;
},
// called when the order is changed, used to show if
// the order is paid or not
order_changes: function(){
var self = this;
var order = [Link].get_order();
if (!order) {
return;
} else if (order.is_paid()) {
self.$('.next').addClass('highlight');
}else{
self.$('.next').removeClass('highlight');
}
},

order_is_valid: function(force_validation) {
var self = this;
var order = [Link].get_order();

// FIXME: this check is there because the backend is unable to

// process empty orders. This is not the right place to fix it.
if (order.get_orderlines().length === 0) {
[Link].show_popup('error',{
'title': _t('Empty Order'),
'body': _t('There must be at least one product in your order before
it can be validated'),
});
return false;
}

var plines = order.get_paymentlines();

 for (var i = 0; i < [Link]; i++) {
if (plines[i].get_type() === 'bank' && plines[i].get_amount() < 0) {
[Link].show_popup('error',{
'message': _t('Negative Bank Payment'),
'comment': _t('You cannot have a negative amount in a Bank
payment. Use a cash payment method to return money to the customer.'),
});
return false;
}
}

if (!order.is_paid() || [Link]) {
return false;
}

// The exact amount must be paid if there is no cash payment method defined.
if ([Link](order.get_total_with_tax() - order.get_total_paid()) > 0.00001) {
var cash = false;
for (var i = 0; i < [Link]; i++) {
cash = cash || ([Link][i].[Link] === 'cash');
}
if (!cash) {
[Link].show_popup('error',{
title: _t('Cannot return change without a cash payment method'),
body: _t('There is no cash payment method available in this point
of sale to handle the change.\n\n Please pay the exact amount or add a cash payment
method in the point of sale configuration'),
});
return false;
}
}

// if the change is too large, it's probably an input error, make the user
confirm.
if (!force_validation && order.get_total_with_tax() > 0 &&
(order.get_total_with_tax() * 1000 < order.get_total_paid())) {
[Link].show_popup('confirm',{
title: _t('Please Confirm Large Amount'),
body: _t('Are you sure that the customer wants to pay') +
' ' +
this.format_currency(order.get_total_paid()) +
' ' +
_t('for an order of') +
' ' +
this.format_currency(order.get_total_with_tax()) +
' ' +
_t('? Clicking "Confirm" will validate the payment.'),
confirm: function() {
self.validate_order('confirm');
},
});
return false;
}

return true;
},

finalize_validation: function() {
var self = this;
var order = [Link].get_order();

if (order.is_paid_with_cash() && [Link].iface_cashdrawer) {

 [Link].open_cashbox();
}

order.initialize_validation_date();

if (order.is_to_invoice()) {
var invoiced = [Link].push_and_invoice_order(order);
[Link] = true;

[Link](function(error){
[Link] = false;
if ([Link] === 'Missing Customer') {
[Link].show_popup('confirm',{
'title': _t('Please select the Customer'),
'body': _t('You need to select the customer before you can
invoice an order.'),
confirm: function(){
[Link].show_screen('clientlist');
},
});
} else if ([Link] < 0) { // XmlHttpRequest Errors
[Link].show_popup('error',{
'title': _t('The order could not be sent'),
'body': _t('Check your internet connection and try again.'),
});
} else if ([Link] === 200) { // OpenERP Server Errors
[Link].show_popup('error-traceback',{
'title': [Link] || _t("Server Error"),
'body': [Link] || _t('The server encountered an
error while receiving your order.'),
});
} else { // ???
[Link].show_popup('error',{
'title': _t("Unknown Error"),
'body': _t("The order could not be sent to the server due to
an unknown error"),
});
}
});

[Link](function(){
[Link] = false;
[Link].show_screen('receipt');
});
} else {
[Link].push_order(order);
[Link].show_screen('receipt');
}

},

// Check if the order is paid, then sends it to the backend,

// and complete the sale process
validate_order: function(force_validation) {
if (this.order_is_valid(force_validation)) {
this.finalize_validation();
}
},
});
gui.define_screen({name:'payment', widget: PaymentScreenWidget});

var set_fiscal_position_button = [Link]({

template: 'SetFiscalPositionButton',
 init: function (parent, options) {
this._super(parent, options);

[Link]('orders').bind('add remove change', function () {

[Link]();
}, this);

[Link]('change:selectedOrder', function () {
[Link]();
}, this);
},
button_click: function () {
var self = this;

var no_fiscal_position = [{
label: _t("None"),
}];
var fiscal_positions = _.map([Link].fiscal_positions, function
(fiscal_position) {
return {
label: fiscal_position.name,
item: fiscal_position
};
});

var selection_list = no_fiscal_position.concat(fiscal_positions);

[Link].show_popup('selection',{
title: _t('Select tax'),
list: selection_list,
confirm: function (fiscal_position) {
var order = [Link].get_order();
order.fiscal_position = fiscal_position;
[Link]('change');
}
});
},
get_current_fiscal_position_name: function () {
var name = _t('Tax');
var order = [Link].get_order();

if (order) {
var fiscal_position = order.fiscal_position;

if (fiscal_position) {
name = fiscal_position.display_name;
}
}

return name;
}
});

define_action_button({
'name': 'set_fiscal_position',
'widget': set_fiscal_position_button,
'condition': function(){
return [Link].fiscal_positions.length > 0;
},
});

return {
ReceiptScreenWidget: ReceiptScreenWidget,
ActionButtonWidget: ActionButtonWidget,
 define_action_button: define_action_button,
ScreenWidget: ScreenWidget,
PaymentScreenWidget: PaymentScreenWidget,
OrderWidget: OrderWidget,
NumpadWidget: NumpadWidget,
ProductScreenWidget: ProductScreenWidget,
ProductListWidget: ProductListWidget,
ClientListScreenWidget: ClientListScreenWidget,
ActionpadWidget: ActionpadWidget,
DomCache: DomCache,
ProductCategoriesWidget: ProductCategoriesWidget,
ScaleScreenWidget: ScaleScreenWidget,
set_fiscal_position_button: set_fiscal_position_button,
};

});
 POS GUI JS
[Link]('point_of_sale.gui', function (require) {
"use strict";
// this file contains the Gui, which is the pos 'controller'.
// It contains high level methods to manipulate the interface
// such as changing between screens, creating popups, etc.
//
// it is available to all pos objects trough the '.gui' field.

var core = require('[Link]');

var Model = require('[Link]');
var formats = require('[Link]');
var session = require('[Link]');

var _t = core._t;

var Gui = [Link]({

screen_classes: [],
popup_classes: [],
init: function(options){
var self = this;
[Link] = [Link];
[Link] = [Link];
this.screen_instances = {};
this.popup_instances = {};
this.default_screen = null;
this.startup_screen = null;
this.current_popup = null;
this.current_screen = null;

[Link](function(){
self.close_other_tabs();
var order = [Link].get_order();
if (order) {
self.show_saved_screen(order);
} else {
self.show_screen(self.startup_screen);
}
[Link]('change:selectedOrder', function(){
self.show_saved_screen([Link].get_order());
});
});
},

/* ---- Gui: SCREEN MANIPULATION ---- */

// register a screen widget to the gui,

// it must have been inserted into the dom.
add_screen: function(name, screen){
[Link]();
this.screen_instances[name] = screen;
},

// sets the screen that will be displayed

// for new orders
set_default_screen: function(name){
this.default_screen = name;
},

// sets the screen that will be displayed

// when no orders are present
set_startup_screen: function(name) {
this.startup_screen = name;
},

// display the screen saved in an order,

// called when the user changes the current order
// no screen saved ? -> display default_screen
// no order ? -> display startup_screen
show_saved_screen: function(order,options) {
options = options || {};
this.close_popup();
if (order) {
this.show_screen(order.get_screen_data('screen') ||
options.default_screen ||
this.default_screen,
null,'refresh');
} else {
this.show_screen(this.startup_screen);
}
},

// display a screen.
// If there is an order, the screen will be saved in the order
// - params: used to load a screen with parameters, for
// example loading a 'product_details' screen for a specific product.
// - refresh: if you want the screen to cycle trough show / hide even
// if you are already on the same screen.
show_screen: function(screen_name,params,refresh,skip_close_popup) {
var screen = this.screen_instances[screen_name];
if (!screen) {
[Link]("ERROR: show_screen("+screen_name+") : screen not found");
}
if (!skip_close_popup){
this.close_popup();
}
var order = [Link].get_order();
if (order) {
var old_screen_name = order.get_screen_data('screen');

order.set_screen_data('screen',screen_name);

if(params){
order.set_screen_data('params',params);
}

if( screen_name !== old_screen_name ){

order.set_screen_data('previous-screen',old_screen_name);
}
}

if (refresh || screen !== this.current_screen) {

if (this.current_screen) {
this.current_screen.close();
this.current_screen.hide();
}
this.current_screen = screen;
this.current_screen.show(refresh);
}
},

// returns the current screen.

get_current_screen: function() {
return [Link].get_order() ? ( [Link].get_order().get_screen_data('screen')
|| this.default_screen ) : this.startup_screen;
},

// goes to the previous screen (as specified in the order). The history only
// goes 1 deep ...
back: function() {
var previous = [Link].get_order().get_screen_data('previous-screen');
if (previous) {
this.show_screen(previous);
}
},

// returns the parameter specified when this screen was displayed

get_current_screen_param: function(param) {
if ([Link].get_order()) {
var params = [Link].get_order().get_screen_data('params');
return params ? params[param] : undefined;
} else {
return undefined;
}
},

/* ---- Gui: POPUP MANIPULATION ---- */

// registers a new popup in the GUI.

// the popup must have been previously inserted
// into the dom.
add_popup: function(name, popup) {
[Link]();
this.popup_instances[name] = popup;
},

// displays a popup. Popup do not stack,

// are not remembered by the order, and are
// closed by screen changes or new popups.
show_popup: function(name,options) {
if (this.current_popup) {
this.close_popup();
}
this.current_popup = this.popup_instances[name];
return this.current_popup.show(options);
},

// close the current popup.

close_popup: function() {
if (this.current_popup) {
this.current_popup.close();
this.current_popup.hide();
this.current_popup = null;
}
},

// is there an active popup ?

has_popup: function() {
return !!this.current_popup;
},

/* ---- Gui: INTER TAB COMM ---- */

// This sets up automatic pos exit when open in

// another tab.
close_other_tabs: function() {
var self = this;
 // avoid closing itself
var now = [Link]();

localStorage['message'] = '';
localStorage['message'] = [Link]({
'message':'close_tabs',
'session': [Link].pos_session.id,
'window_uid': now,
});

// storage events are (most of the time) triggered only when the
// localstorage is updated in a different tab.
// some browsers (e.g. IE) does trigger an event in the same tab
// This may be a browser bug or a different interpretation of the HTML spec
// cf [Link]
event-fired-in-source-window
// Use window_uid parameter to exclude the current window
[Link]("storage", function(event) {
var msg = [Link];

if ( [Link] === 'message' && [Link]) {

var msg = [Link]([Link]);

if ( [Link] === 'close_tabs' &&
[Link] == [Link].pos_session.id &&
msg.window_uid != now) {

[Link]('POS / Session opened in another window. EXITING

POS')
self._close();
}
}

}, false);
},

/* ---- Gui: ACCESS CONTROL ---- */

// A Generic UI that allow to select a user from a list.

// It returns a deferred that resolves with the selected user
// upon success. Several options are available :
// - security: passwords will be asked
// - only_managers: restricts the list to managers
// - current_user: password will not be asked if this
// user is selected.
// - title: The title of the user selection list.
select_user: function(options){
options = options || {};
var self = this;
var def = new $.Deferred();

var list = [];

for (var i = 0; i < [Link]; i++) {
var user = [Link][i];
if (!options.only_managers || [Link] === 'manager') {
[Link]({
'label': [Link],
'item': user,
});
}
}
 this.show_popup('selection',{
'title': [Link] || _t('Select User'),
list: list,
confirm: function(user){ [Link](user); },
cancel: function(){ [Link](); },
});

return [Link](function(user){
if ([Link] && user !== options.current_user &&
user.pos_security_pin) {
return self.ask_password(user.pos_security_pin).then(function(){
return user;
});
} else {
return user;
}
});
},

// Ask for a password, and checks if it this

// the same as specified by the function call.
// returns a deferred that resolves on success,
// fails on failure.
ask_password: function(password) {
var self = this;
var ret = new $.Deferred();
if (password) {
this.show_popup('password',{
'title': _t('Password ?'),
confirm: function(pw) {
if (pw !== password) {
self.show_popup('error',_t('Incorrect Password'));
[Link]();
} else {
[Link]();
}
},
});
} else {
[Link]();
}
return ret;
},

// checks if the current user (or the user provided) has manager
// access rights. If not, a popup is shown allowing the user to
// temporarily login as an administrator.
// This method returns a deferred, that succeeds with the
// manager user when the login is successfull.
sudo: function(user){
user = user || [Link].get_cashier();

if ([Link] === 'manager') {

return new $.Deferred().resolve(user);
} else {
return this.select_user({
security: true,
only_managers: true,
title: _t('Login as a Manager'),
});
}
},
 /* ---- Gui: CLOSING THE POINT OF SALE ---- */

close: function() {
var self = this;
var pending = [Link].get_orders().length;

if (!pending) {
this._close();
} else {
[Link].push_order().always(function() {
var pending = [Link].get_orders().length;
if (!pending) {
self._close();
} else {
var reason = [Link]('failed') ?
'configuration errors' :
'internet connection issues';

self.show_popup('confirm', {
'title': _t('Offline Orders'),
'body': _t(['Some orders could not be submitted to',
'the server due to ' + reason + '.',
'You can exit the Point of Sale, but do',
'not close the session before the issue',
'has been resolved.'].join(' ')),
'confirm': function() {
self._close();
},
});
}
});
}
},

_close: function() {
var self = this;
[Link].loading_show();
[Link].loading_message(_t('Closing ...'));

[Link].push_order().then(function(){
var url = "/web#action=point_of_sale.action_client_pos_menu";
[Link] = [Link] ? $.[Link](url, {debug:
[Link]}) : url;
});
},

/* ---- Gui: SOUND ---- */

play_sound: function(sound) {
var src = '';
if (sound === 'error') {
src = "/point_of_sale/static/src/sounds/[Link]";
} else if (sound === 'bell') {
src = "/point_of_sale/static/src/sounds/[Link]";
} else {
[Link]('Unknown sound: ',sound);
return;
}
$('body').append('<audio src="'+src+'" autoplay="true"></audio>');
},

/* ---- Gui: FILE I/O ---- */

 // This will make the browser download 'contents' as a
// file named 'name'
// if 'contents' is not a string, it is converted into
// a JSON representation of the contents.

// TODO: remove me in master: deprecated in favor of prepare_download_link

// this method is kept for backward compatibility but is likely not going
// to work as many browsers do to not accept fake click events on links
download_file: function(contents, name) {
href_params = this.prepare_file_blob(contents,name);
var evt = [Link]("HTMLEvents");
[Link]("click");

$("<a>",href_params).get(0).dispatchEvent(evt);

},

prepare_download_link: function(contents, filename, src, target) {

var href_params = this.prepare_file_blob(contents, filename);

$(target).parent().attr(href_params);
$(src).addClass('oe_hidden');
$(target).removeClass('oe_hidden');

// hide again after click

$(target).click(function() {
$(src).removeClass('oe_hidden');
$(this).addClass('oe_hidden');
});
},

prepare_file_blob: function(contents, name) {

var URL = [Link] || [Link];

if (typeof contents !== 'string') {

contents = [Link](contents,null,2);
}

var blob = new Blob([contents]);

return {download: name || '[Link]',

href: [Link](blob),}
},

/* ---- Gui: EMAILS ---- */

// This will launch the user's email software

// with a new email with the address, subject and body
// prefilled.

send_email: function(address, subject, body) {

[Link]("[Link] + address +
"?subject=" + (subject ? [Link](subject)
: '') +
"&body=" + (body ? [Link](body) : ''));
},

/* ---- Gui: KEYBOARD INPUT ---- */

// This is a helper to handle numpad keyboard input.

// - buffer: an empty or number string
// - input: '[0-9],'+','-','.','CLEAR','BACKSPACE'
 // - options: 'firstinput' -> will clear buffer if
// input is '[0-9]' or '.'
// returns the new buffer containing the modifications
// (the original is not touched)
numpad_input: function(buffer, input, options) {
var newbuf = [Link](0);
options = options || {};
var newbuf_float = formats.parse_value(newbuf, {type: "float"}, 0);
var decimal_point = _t.[Link].decimal_point;

if (input === decimal_point) {

if ([Link]) {
newbuf = "0.";
}else if (![Link] || newbuf === '-') {
newbuf += "0.";
} else if ([Link](decimal_point) < 0){
newbuf = newbuf + decimal_point;
}
} else if (input === 'CLEAR') {
newbuf = "";
} else if (input === 'BACKSPACE') {
newbuf = [Link](0,[Link] - 1);
} else if (input === '+') {
if ( newbuf[0] === '-' ) {
newbuf = [Link](1,[Link]);
}
} else if (input === '-') {
if ( newbuf[0] === '-' ) {
newbuf = [Link](1,[Link]);
} else {
newbuf = '-' + newbuf;
}
} else if (input[0] === '+' && !isNaN(parseFloat(input))) {
newbuf = [Link].format_currency_no_symbol(newbuf_float +
parseFloat(input));
} else if (!isNaN(parseInt(input))) {
if ([Link]) {
newbuf = '' + input;
} else {
newbuf += input;
}
}

// End of input buffer at 12 characters.

if ([Link] > [Link] && [Link] > 12) {
this.play_sound('bell');
return [Link](0);
}

return newbuf;
},
});

var define_screen = function (classe) {

[Link].screen_classes.push(classe);
};

var define_popup = function (classe) {

[Link].popup_classes.push(classe);
};

return {
Gui: Gui,
 define_screen: define_screen,
define_popup: define_popup,
};

});
 HAIRSTYLIST JS
[Link]('pos_snips_updates.hair_stylist', function (require) {
"use strict";
var Class = require('[Link]');
var Model = require('[Link]');
var session = require('[Link]');
var core = require('[Link]');
var screens = require('point_of_sale.screens');
var gui = require('point_of_sale.gui');
var pos_model = require('point_of_sale.models');
var utils = require('[Link]');
var _t = core._t;

var BarcodeParser = require('[Link]');

var PopupWidget = require('point_of_sale.popups');
var ScreenWidget = [Link];
var PaymentScreenWidget = [Link];
var round_pr = utils.round_precision;

var models = require('point_of_sale.models');

var QWeb = [Link];

models.load_models({
model: '[Link]',
fields: ['name', 'id',],
loaded: function (self, employees) {
[Link] = employees;
self.employees_by_id = {};
for (var i = 0; i < [Link]; i++) {
employees[i].tables = [];
self.employees_by_id[employees[i].id] = employees[i];
}

// Make sure they display in the correct order

[Link] = [Link](function (a, b) {
return [Link] - [Link];
});

// Ignore floorplan features if no floor specified.

// [Link].iface_floorplan = !![Link];
},
});

var _super_orderline = [Link];

[Link] = [Link]({
initialize: function (attr, options) {
_super_orderline.[Link](this, attr, options);
// this.hair_stylist_id = this.hair_stylist_id || false;
// this.hair_stylist_name = this.hair_stylist_name || "";
if (!this.hair_stylist_id) {
this.hair_stylist_id = [Link].hair_stylist_id;
}
if (!this.hair_stylist_name) {
this.hair_stylist_name = [Link].hair_stylist_name;
}

},
 set_hair_stylist_id: function (hair_stylist_id) {
this.hair_stylist_id = hair_stylist_id;
[Link]('change', this);
},
get_hair_stylist_id: function () {
return this.hair_stylist_id;
},
set_hair_stylist_name: function (hair_stylist_name) {
this.hair_stylist_name = hair_stylist_name;
[Link]('change', this);
},
get_hair_stylist_name: function () {
return this.hair_stylist_name;
},

clone: function () {
var orderline = _super_orderline.[Link](this);
orderline.hair_stylist_id = this.hair_stylist_id;
orderline.hair_stylist_name = this.hair_stylist_name;
return orderline;
},
export_as_JSON: function () {
var json = _super_orderline.export_as_JSON.call(this);
json.hair_stylist_id = this.hair_stylist_id;
json.hair_stylist_name = this.hair_stylist_name;
return json;
},
init_from_JSON: function (json) {
_super_orderline.init_from_JSON.apply(this, arguments);
this.hair_stylist_id = json.hair_stylist_id;
this.hair_stylist_name = json.hair_stylist_name;
},
});

var OrderlineHairStylistButton = [Link]({

template: 'OrderlineHairStylistButton',
button_click: function () {
var line = [Link].get_order().get_selected_orderline();
if (line) {
var list = [];

[Link]("OrderlineHairStylistButton");
var hair_stylists=[Link];
var hair_stylists_length=hair_stylists.length;

for (var i = 0; i < hair_stylists_length; i++) {

var hair_stylist = hair_stylists[i];

[Link]({
'label': hair_stylist.name,
'item': hair_stylist,
});

}
//
//
var the_seleted=line.get_hair_stylist_name();
[Link].show_popup('selection',{
'title':_t('Select Hair Stylist'),
list: list,
confirm: function (item) {
[Link]("Item");
 [Link](item);
line.set_hair_stylist_id([Link]);
line.set_hair_stylist_name([Link]);
},
cancel: function () { },
});

}
},
});

screens.define_action_button({
'name': 'orderline_note',
'widget': OrderlineHairStylistButton,

});

});
 INTERNAL REFERENCE JS
[Link]('pos_snips_updates.internal_reference', function (require) {
"use strict";

var models = require('point_of_sale.models');

var screens = require('point_of_sale.screens');
var core = require('[Link]');
var utils = require('[Link]');
var QWeb = [Link];
var _t = core._t;

// New orders are now associated with the current table, if any.
var _super_order = [Link];
[Link] = [Link]({
initialize: function () {
[Link]("internal_reference start")
_super_order.[Link](this, arguments);
if (!this.internal_reference) {
this.internal_reference = [Link].internal_reference;
}

this.save_to_db();
},
export_as_JSON: function () {
var json = _super_order.export_as_JSON.apply(this, arguments);
json.internal_reference = this.internal_reference;
return json;
},
init_from_JSON: function (json) {
_super_order.init_from_JSON.apply(this, arguments);
this.internal_reference = json.internal_reference || '';
},
export_for_printing: function () {
var json = _super_order.export_for_printing.apply(this, arguments);
json.internal_reference = this.get_internal_reference();
return json;
},
get_internal_reference: function () {
return this.internal_reference;
},
set_internal_reference: function (internal_reference) {
this.internal_reference = internal_reference;
[Link]('change');
},
});

var InternalReferenceButton = [Link]({

template: 'InternalReferenceButton',
internal_reference: function () {
if ([Link].get_order()) {
return [Link].get_order().internal_reference;
} else {
return '';
}
},
button_click: function () {
var self = this;
[Link].show_popup('textinput', {
'title': _t('Internal Reference ?'),
'value': [Link].get_order().get_internal_reference(),
 'confirm': function (value) {
[Link].get_order().set_internal_reference(value);
},
});
},
});

var PrintSessionButton = [Link]({

template: 'PrintSessionButton',

button_click: function () {
var self = this;

[Link](" ..... Action TO Report PrintSession ...... ");

[Link](" from order session_id=" + [Link].get_order().session_id);

[Link](" from cookie session_id=" + utils.get_cookie("session_id"));

var session_id = [Link].get_order().session_id;

if (session_id) {

} else {
var session_id = utils.get_cookie("session_id");
}
[Link]("session_id=" + session_id);

if (session_id) {

var additional_context = {active_ids: [session_id]}

self.do_action('pos_snips_updates.action_pos_snips_updates_report', {
additional_context: {active_ids: [session_id],}
});

//
self.do_action('pos_customer_history.action_report_customer_history', {
// additional_context: { active_ids: [self.so_id.id], } });
}

},
});

[Link]({
update_summary: function () {
this._super();
if ([Link]().action_buttons &&
[Link]().action_buttons.internal_reference) {
[Link]().action_buttons.internal_reference.renderElement();
}
},
});

screens.define_action_button({
'name': 'internal_reference',
'widget': InternalReferenceButton,

});

screens.define_action_button({
'name': 'PrintSessionButton',
 'widget': PrintSessionButton,

});

});
 POS CUSTOMER HISTORY JS
[Link]('pos_customer_history.customer_history', function (require) {
"use strict";

var Class = require('[Link]');

var Model = require('[Link]');
var session = require('[Link]');
var core = require('[Link]');
var screens = require('point_of_sale.screens');
var gui = require('point_of_sale.gui');
var pos_model = require('point_of_sale.models');
var utils = require('[Link]');
var _t = core._t;

var BarcodeParser = require('[Link]');

var PopupWidget = require('point_of_sale.popups');
var ScreenWidget = [Link];
var PaymentScreenWidget = [Link];
var round_pr = utils.round_precision;

var models = require('point_of_sale.models');

var QWeb = [Link];

var _super_orderline = [Link];

//get customer number of orders and total of them

[Link]({
initialize: function () {
[Link]("init ClientListScreenWidget");
this.count_orders = this.count_orders ? this.get_count_orders() : 0;
this.total_orders = this.total_orders ? this.get_total_orders() : 0;
[Link] = [Link] ? this.get_average() : 0;
this.last_visit = this.last_visit ? this.get_last_visit() : '';

},
show: function () {
var self = this;
this._super();
this.$('.customer-history').click(function () {
// alert("customer");
[Link]("Action
pos_customer_history.action_report_customer_history");

if (self.new_client) {
[Link]("Client id=" + self.new_client.id)

var additional_context = { active_ids: [self.new_client.id] }

self.do_action('pos_customer_history.action_report_customer_history', {
additional_context: { active_ids: [self.new_client.id], }
});
}
});

},
get_count_orders: function () {
return this.count_orders;
},
set_count_orders: function (count_orders) {
this.count_orders = count_orders;
[Link]('change');
 },
get_last_visit: function () {
return this.last_visit;
},
set_last_visit: function (last_visit) {
this.last_visit = last_visit;
[Link]('change');
},
get_average: function () {
return [Link];
},
set_average: function (average) {
[Link] = average;
[Link]('change');
},
get_total_orders: function () {
return this.total_orders;
},
set_total_orders: function (total_orders) {
this.total_orders = total_orders;
[Link]('change');
},
display_client_details: function (visibility, partner, clickpos) {
var self = this;
var contents = this.$('.client-details-contents');
var parent = this.$('.client-list').parent();
var scroll = [Link]();
var height = [Link]();

[Link]('click', '.[Link]');
[Link]('click', '.[Link]');
[Link]('click', '.[Link]');
[Link]('click', '.[Link]', function () {
self.edit_client_details(partner);
});
[Link]('click', '.[Link]', function () {
self.save_client_details(partner);
});
[Link]('click', '.[Link]', function () {
self.undo_client_details(partner);
});
this.editing_client = false;
this.uploaded_picture = null;

if (visibility === 'show') {

[Link]();

var posOrderModel = new Model('[Link]');

var temp=this;
[Link](temp);
[Link](partner);

[Link]('get_partner_history',[[Link]]).then(function(history_lst) {
[Link]();
temp.set_last_visit(history_lst[3]);
temp.set_average(history_lst[2]);
temp.set_count_orders(history_lst[1]);
temp.set_total_orders(history_lst[0]);

[Link]($([Link]('ClientDetails',{widget:temp,partner:partner})));

[Link](temp);
 });

[Link]($([Link]('ClientDetails', {widget: this, partner:

partner})));

var new_height = [Link]();

if (!this.details_visible) {
// resize client list to take into account client details
[Link]('-=' + new_height);

if (clickpos < scroll + new_height + 20) {

[Link](clickpos - 20);
} else {
[Link]([Link]() + new_height);
}
} else {
[Link]([Link]() - height + new_height);
}

this.details_visible = true;
this.toggle_save_button();
} else if (visibility === 'edit') {
this.editing_client = true;
[Link]();
[Link]($([Link]('ClientDetailsEdit', {widget: this,
partner: partner})));
this.toggle_save_button();

// Browsers attempt to scroll invisible input elements

// into view (eg. when hidden behind keyboard). They don't
// seem to take into account that some elements are not
// scrollable.
[Link]('input').blur(function () {
setTimeout(function () {
self.$('.window').scrollTop(0);
}, 0);
});

[Link]('.image-uploader').on('change', function (event) {

self.load_image_file([Link][0], function (res) {
if (res) {
[Link]('.client-picture img, .client-picture
.fa').remove();
[Link]('.client-picture').append("<img src='" + res
+ "'>");
[Link]('.[Link]').remove();
self.uploaded_picture = res;
}
});
});
} else if (visibility === 'hide') {
[Link]();
[Link]('100%');
if (height > scroll) {
[Link]({height: height + 'px'});
[Link]({height: 0}, 400, function () {
[Link]({height: ''});
});
 } else {
[Link]([Link]() - height);
}
this.details_visible = false;
this.toggle_save_button();
}
},

});

});