size
int64 0
304k
| ext
stringclasses 1
value | lang
stringclasses 1
value | branch
stringclasses 1
value | content
stringlengths 0
304k
| avg_line_length
float64 0
238
| max_line_length
int64 0
304k
|
|---|---|---|---|---|---|---|
1,096 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2022 XCG Consulting <https://xcg-consulting.fr/>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import api, models
_logger = logging.getLogger(__name__)
ALLOW_SAML_UID_AND_PASSWORD = "auth_saml.allow_saml_uid_and_internal_password"
class IrConfigParameter(models.Model):
"""Redefined to update users when our parameter is changed."""
_inherit = "ir.config_parameter"
@api.model_create_multi
def create(self, vals_list):
"""Redefined to update users when our parameter is changed."""
result = super().create(vals_list)
if result.filtered(lambda param: param.key == ALLOW_SAML_UID_AND_PASSWORD):
self.env["res.users"].allow_saml_and_password_changed()
return result
def write(self, vals):
"""Redefined to update users when our parameter is changed."""
result = super().write(vals)
if self.filtered(lambda param: param.key == ALLOW_SAML_UID_AND_PASSWORD):
self.env["res.users"].allow_saml_and_password_changed()
return result
| 37.793103 | 1,096 |
12,398 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2020 Glodo UK <https://www.glodo.uk/>
# Copyright (C) 2010-2016, 2022 XCG Consulting <https://xcg-consulting.fr/>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import base64
import json
import logging
import os
import tempfile
import urllib.parse
# dependency name is pysaml2 # pylint: disable=W7936
import saml2
import saml2.xmldsig as ds
from saml2.client import Saml2Client
from saml2.config import Config as Saml2Config
from odoo import api, fields, models
_logger = logging.getLogger(__name__)
class AuthSamlProvider(models.Model):
"""Configuration values of a SAML2 provider"""
_name = "auth.saml.provider"
_description = "SAML2 Provider"
_order = "sequence, name"
name = fields.Char("Provider Name", required=True, index=True)
entity_id = fields.Char(
"Entity ID",
help="EntityID passed to IDP, used to identify the Odoo",
required=True,
default="odoo",
)
idp_metadata = fields.Text(
string="Identity Provider Metadata",
help=(
"Configuration for this Identity Provider. Supplied by the"
" provider, in XML format."
),
required=True,
)
sp_baseurl = fields.Text(
string="Override Base URL",
help="""Base URL sent to Odoo with this, rather than automatically
detecting from request or system parameter web.base.url""",
)
sp_pem_public = fields.Binary(
string="Odoo Public Certificate",
attachment=True,
required=True,
)
sp_pem_public_filename = fields.Char("Odoo Public Certificate File Name")
sp_pem_private = fields.Binary(
string="Odoo Private Key",
attachment=True,
required=True,
)
sp_pem_private_filename = fields.Char("Odoo Private Key File Name")
sp_metadata_url = fields.Char(
compute="_compute_sp_metadata_url",
string="Metadata URL",
readonly=True,
)
matching_attribute = fields.Char(
string="Identity Provider matching attribute",
default="subject.nameId",
required=True,
help=(
"Attribute to look for in the returned IDP response to match"
" against an Odoo user."
),
)
matching_attribute_to_lower = fields.Boolean(
string="Lowercase IDP Matching Attribute",
help="Force matching_attribute to lower case before passing back to Odoo.",
)
attribute_mapping_ids = fields.One2many(
"auth.saml.attribute.mapping",
"provider_id",
string="Attribute Mapping",
)
active = fields.Boolean(default=True)
sequence = fields.Integer(index=True)
css_class = fields.Char(
string="Button Icon CSS class",
help="Add a CSS class that serves you to style the login button.",
)
body = fields.Char(string="Button Description")
autoredirect = fields.Boolean(
"Automatic Redirection",
default=False,
help="Only the provider with the higher priority will be automatically "
"redirected",
)
sig_alg = fields.Selection(
selection=lambda s: s._sig_alg_selection(),
required=True,
string="Signature Algorithm",
)
# help string is from pysaml2 documentation
authn_requests_signed = fields.Boolean(
default=True,
help="Indicates if the Authentication Requests sent by this SP should be signed"
" by default.",
)
logout_requests_signed = fields.Boolean(
default=True,
help="Indicates if this entity will sign the Logout Requests originated from it"
".",
)
want_assertions_signed = fields.Boolean(
default=True,
help="Indicates if this SP wants the IdP to send the assertions signed.",
)
want_response_signed = fields.Boolean(
default=True,
help="Indicates that Authentication Responses to this SP must be signed.",
)
want_assertions_or_response_signed = fields.Boolean(
default=True,
help="Indicates that either the Authentication Response or the assertions "
"contained within the response to this SP must be signed.",
)
# this one is used in Saml2Client.prepare_for_authenticate
sign_authenticate_requests = fields.Boolean(
default=True,
help="Whether the request should be signed or not",
)
sign_metadata = fields.Boolean(
default=True,
help="Whether metadata should be signed or not",
)
@api.model
def _sig_alg_selection(self):
return [(sig[0], sig[0]) for sig in ds.SIG_ALLOWED_ALG]
@api.onchange("name")
def _onchange_name(self):
if not self.body:
self.body = self.name
@api.depends("sp_baseurl")
def _compute_sp_metadata_url(self):
icp_base_url = (
self.env["ir.config_parameter"].sudo().get_param("web.base.url", "")
)
for record in self:
if isinstance(record.id, models.NewId):
record.sp_metadata_url = False
continue
base_url = icp_base_url
if record.sp_baseurl:
base_url = record.sp_baseurl
qs = urllib.parse.urlencode({"p": record.id, "d": self.env.cr.dbname})
record.sp_metadata_url = urllib.parse.urljoin(
base_url, ("/auth_saml/metadata?%s" % qs)
)
def _get_cert_key_path(self, field="sp_pem_public"):
self.ensure_one()
model_attachment = self.env["ir.attachment"].sudo()
keys = model_attachment.search(
[
("res_model", "=", self._name),
("res_field", "=", field),
("res_id", "=", self.id),
],
limit=1,
)
if model_attachment._storage() != "file":
# For non-file locations we need to create a temp file to pass to pysaml.
fd, keys_path = tempfile.mkstemp()
with open(keys_path, "wb") as f:
f.write(base64.b64decode(keys.datas))
os.close(fd)
else:
keys_path = model_attachment._full_path(keys.store_fname)
return keys_path
def _get_config_for_provider(self, base_url: str = None):
"""
Internal helper to get a configured Saml2Client
"""
self.ensure_one()
if self.sp_baseurl:
base_url = self.sp_baseurl
if not base_url:
base_url = (
self.env["ir.config_parameter"].sudo().get_param("web.base.url", "")
)
acs_url = urllib.parse.urljoin(base_url, "/auth_saml/signin")
settings = {
"metadata": {"inline": [self.idp_metadata]},
"entityid": self.entity_id,
"service": {
"sp": {
"endpoints": {
"assertion_consumer_service": [
(acs_url, saml2.BINDING_HTTP_REDIRECT),
(acs_url, saml2.BINDING_HTTP_POST),
(acs_url, saml2.BINDING_HTTP_REDIRECT),
(acs_url, saml2.BINDING_HTTP_POST),
],
},
"allow_unsolicited": False,
"authn_requests_signed": self.authn_requests_signed,
"logout_requests_signed": self.logout_requests_signed,
"want_assertions_signed": self.want_assertions_signed,
"want_response_signed": self.want_response_signed,
"want_assertions_or_response_signed": (
self.want_assertions_or_response_signed
),
},
},
"cert_file": self._get_cert_key_path("sp_pem_public"),
"key_file": self._get_cert_key_path("sp_pem_private"),
}
sp_config = Saml2Config()
sp_config.load(settings)
sp_config.allow_unknown_attributes = True
return sp_config
def _get_client_for_provider(self, base_url: str = None):
sp_config = self._get_config_for_provider(base_url)
saml_client = Saml2Client(config=sp_config)
return saml_client
def _get_auth_request(self, extra_state=None, url_root=None):
"""
build an authentication request and give it back to our client
"""
self.ensure_one()
if extra_state is None:
extra_state = {}
state = {
"d": self.env.cr.dbname,
"p": self.id,
}
state.update(extra_state)
sig_alg = ds.SIG_RSA_SHA1
if self.sig_alg:
sig_alg = getattr(ds, self.sig_alg)
saml_client = self._get_client_for_provider(url_root)
reqid, info = saml_client.prepare_for_authenticate(
sign=self.sign_authenticate_requests,
relay_state=json.dumps(state),
sigalg=sig_alg,
)
redirect_url = None
# Select the IdP URL to send the AuthN request to
for key, value in info["headers"]:
if key == "Location":
redirect_url = value
self._store_outstanding_request(reqid)
return redirect_url
def _validate_auth_response(self, token: str, base_url: str = None):
"""return the validation data corresponding to the access token"""
self.ensure_one()
client = self._get_client_for_provider(base_url)
response = client.parse_authn_request_response(
token,
saml2.entity.BINDING_HTTP_POST,
self._get_outstanding_requests_dict(),
)
matching_value = None
if self.matching_attribute == "subject.nameId":
matching_value = response.name_id.text
else:
attrs = response.get_identity()
for k, v in attrs.items():
if k == self.matching_attribute:
matching_value = v
break
if not matching_value:
raise Exception(
"Matching attribute %s not found in user attrs: %s"
% (self.matching_attribute, attrs)
)
if matching_value and isinstance(matching_value, list):
matching_value = next(iter(matching_value), None)
if isinstance(matching_value, str) and self.matching_attribute_to_lower:
matching_value = matching_value.lower()
vals = {"user_id": matching_value}
post_vals = self._hook_validate_auth_response(response, matching_value)
if post_vals:
vals.update(post_vals)
return vals
def _get_outstanding_requests_dict(self):
self.ensure_one()
requests = (
self.env["auth_saml.request"]
.sudo()
.search([("saml_provider_id", "=", self.id)])
)
return {record.saml_request_id: record.id for record in requests}
def _store_outstanding_request(self, reqid):
self.ensure_one()
self.env["auth_saml.request"].sudo().create(
{"saml_provider_id": self.id, "saml_request_id": reqid}
)
def _metadata_string(self, valid=None, base_url=None):
self.ensure_one()
sp_config = self._get_config_for_provider(base_url)
return saml2.metadata.create_metadata_string(
None,
config=sp_config,
valid=valid,
cert=self._get_cert_key_path("sp_pem_public"),
keyfile=self._get_cert_key_path("sp_pem_private"),
sign=self.sign_metadata,
)
def _hook_validate_auth_response(self, response, matching_value):
self.ensure_one()
vals = {}
attrs = response.get_identity()
for attribute in self.attribute_mapping_ids:
if attribute.attribute_name not in attrs:
_logger.debug(
"SAML attribute '%s' found in response %s",
attribute.attribute_name,
attrs,
)
continue
attribute_value = attrs[attribute.attribute_name]
if isinstance(attribute_value, list):
attribute_value = attribute_value[0]
vals[attribute.field_name] = attribute_value
return {"mapped_attrs": vals}
| 33.598916 | 12,398 |
6,981 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2020 GlodoUK <https://www.glodo.uk>
# Copyright (C) 2010-2016 XCG Consulting <http://odoo.consulting>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from typing import Set
import passlib
from odoo import SUPERUSER_ID, _, api, fields, models, registry, tools
from odoo.exceptions import AccessDenied, ValidationError
from .ir_config_parameter import ALLOW_SAML_UID_AND_PASSWORD
_logger = logging.getLogger(__name__)
class ResUser(models.Model):
"""
Add SAML login capabilities to Odoo users.
"""
_inherit = "res.users"
saml_ids = fields.One2many("res.users.saml", "user_id")
def _auth_saml_validate(self, provider_id: int, token: str, base_url: str = None):
provider = self.env["auth.saml.provider"].sudo().browse(provider_id)
return provider._validate_auth_response(token, base_url)
def _auth_saml_signin(self, provider: int, validation: dict, saml_response) -> str:
"""Sign in Odoo user corresponding to provider and validated access token.
:param provider: SAML provider id
:param validation: result of validation of access token
:param saml_response: saml parameters response from the IDP
:return: user login
:raise: odoo.exceptions.AccessDenied if signin failed
This method can be overridden to add alternative signin methods.
"""
saml_uid = validation["user_id"]
user_saml = self.env["res.users.saml"].search(
[("saml_uid", "=", saml_uid), ("saml_provider_id", "=", provider)],
limit=1,
)
user = user_saml.user_id
if len(user) != 1:
raise AccessDenied()
with registry(self.env.cr.dbname).cursor() as new_cr:
new_env = api.Environment(new_cr, self.env.uid, self.env.context)
# Update the token. Need to be committed, otherwise the token is not visible
# to other envs, like the one used in login_and_redirect
user_saml.with_env(new_env).write({"saml_access_token": saml_response})
if validation.get("mapped_attrs", {}):
user.write(validation.get("mapped_attrs", {}))
return user.login
@api.model
def auth_saml(self, provider: int, saml_response: str, base_url: str = None):
validation = self._auth_saml_validate(provider, saml_response, base_url)
# required check
if not validation.get("user_id"):
raise AccessDenied()
# retrieve and sign in user
login = self._auth_saml_signin(provider, validation, saml_response)
if not login:
raise AccessDenied()
# return user credentials
return self.env.cr.dbname, login, saml_response
def _check_credentials(self, password, env):
"""Override to handle SAML auths.
The token can be a password if the user has used the normal form...
but we are more interested in the case when they are tokens
and the interesting code is inside the "except" clause.
"""
try:
# Attempt a regular login (via other auth addons) first.
return super()._check_credentials(password, env)
except (AccessDenied, passlib.exc.PasswordSizeError):
# since normal auth did not succeed we now try to find if the user
# has an active token attached to his uid
token = (
self.env["res.users.saml"]
.sudo()
.search(
[
("user_id", "=", self.env.user.id),
("saml_access_token", "=", password),
]
)
)
if token:
return
raise AccessDenied() from None
@api.model
def _saml_allowed_user_ids(self) -> Set[int]:
"""Users that can have a password even if the option to disallow it is set.
It includes superuser and the admin if it exists.
"""
allowed_users = {SUPERUSER_ID}
user_admin = self.env.ref("base.user_admin", False)
if user_admin:
allowed_users.add(user_admin.id)
return allowed_users
@api.model
def allow_saml_and_password(self) -> bool:
"""Can both SAML and local password auth methods coexist."""
return tools.str2bool(
self.env["ir.config_parameter"]
.sudo()
.get_param(ALLOW_SAML_UID_AND_PASSWORD)
)
def _set_password(self):
"""Inverse method of the password field."""
# Redefine base method to block setting password on users with SAML ids
# And also to be able to set password to a blank value
if not self.allow_saml_and_password():
saml_users = self.filtered(
lambda user: user.sudo().saml_ids
and user.id not in self._saml_allowed_user_ids()
and user.password
)
if saml_users:
# same error as an api.constrains because it is a constraint.
# a standard constrains would require the use of SQL as the password
# field is obfuscated by the base module.
raise ValidationError(
_(
"This database disallows users to "
"have both passwords and SAML IDs. "
"Error for logins %s"
)
% saml_users.mapped("login")
)
# handle setting password to NULL
blank_password_users = self.filtered(lambda user: user.password is False)
non_blank_password_users = self - blank_password_users
if non_blank_password_users:
# pylint: disable=protected-access
super(ResUser, non_blank_password_users)._set_password()
if blank_password_users:
# similar to what Odoo does in Users._set_encrypted_password
self.env.cr.execute(
"UPDATE res_users SET password = NULL WHERE id IN %s",
(tuple(blank_password_users.ids),),
)
self.invalidate_cache(["password"], blank_password_users.ids)
return
def allow_saml_and_password_changed(self):
"""Called after the parameter is changed."""
if not self.allow_saml_and_password():
# sudo because the user doing the parameter change might not have the right
# to search or write users
users_to_blank_password = self.sudo().search(
[
"&",
("saml_ids", "!=", False),
("id", "not in", list(self._saml_allowed_user_ids())),
]
)
_logger.debug(
"Removing password from %s user(s)", len(users_to_blank_password)
)
users_to_blank_password.write({"password": False})
| 38.783333 | 6,981 |
524 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2010-2016, 2022 XCG Consulting <http://odoo.consulting>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
from .ir_config_parameter import ALLOW_SAML_UID_AND_PASSWORD
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
allow_saml_uid_and_internal_password = fields.Boolean(
"Allow SAML users to possess an Odoo password (warning: decreases security)",
config_parameter=ALLOW_SAML_UID_AND_PASSWORD,
)
| 34.933333 | 524 |
620 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2020 GlodoUK <https://glodo.uk/>
# Copyright (C) 2022 XCG Consulting <https://xcg-consulting.fr/>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class AuthSamlRequest(models.TransientModel):
_name = "auth_saml.request"
_description = "SAML Outstanding Requests"
_rec_name = "saml_request_id"
saml_provider_id = fields.Many2one(
"auth.saml.provider",
string="SAML Provider that issued the token",
required=True,
)
saml_request_id = fields.Char(
"Current Request ID",
required=True,
)
| 29.52381 | 620 |
10,242 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2020 GlodoUK <https://www.glodo.uk/>
# Copyright (C) 2010-2016, 2022 XCG Consulting <https://xcg-consulting.fr/>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import functools
import json
import logging
import werkzeug.utils
from werkzeug.urls import url_quote_plus
import odoo
from odoo import SUPERUSER_ID, _, api, http, models, registry as registry_get
from odoo.http import request
from odoo.addons.web.controllers.main import (
Home,
Session as WebSession,
ensure_db,
login_and_redirect,
set_cookie_and_redirect,
)
_logger = logging.getLogger(__name__)
# ----------------------------------------------------------
# helpers
# ----------------------------------------------------------
def fragment_to_query_string(func):
@functools.wraps(func)
def wrapper(self, req, **kw):
if not kw:
return """<html><head><script>
var l = window.location;
var q = l.hash.substring(1);
var r = '/' + l.search;
if(q.length !== 0) {
var s = l.search ? (l.search === '?' ? '' : '&') : '?';
r = l.pathname + l.search + s + q;
}
window.location = r;
</script></head><body></body></html>"""
return func(self, req, **kw)
return wrapper
# ----------------------------------------------------------
# Controller
# ----------------------------------------------------------
class SAMLLogin(Home):
def _list_saml_providers_domain(self):
return []
def list_saml_providers(self, with_autoredirect: bool = False) -> models.Model:
"""Return available providers
:param with_autoredirect: True to only list providers with automatic redirection
:return: a recordset of providers
"""
domain = self._list_saml_providers_domain()
if with_autoredirect:
domain.append(("autoredirect", "=", True))
providers = request.env["auth.saml.provider"].sudo().search_read(domain)
for provider in providers:
# Compatibility with auth_oauth/controllers/main.py in order to
# avoid KeyError rendering template_auth_oauth_providers
provider.setdefault("auth_link", "")
return providers
def _saml_autoredirect(self):
# automatically redirect if any provider is set up to do that
autoredirect_providers = self.list_saml_providers(True)
# do not redirect if asked too or if a SAML error has been found
disable_autoredirect = (
"disable_autoredirect" in request.params or "error" in request.params
)
if autoredirect_providers and not disable_autoredirect:
return werkzeug.utils.redirect(
"/auth_saml/get_auth_request?pid=%d" % autoredirect_providers[0]["id"],
303,
)
return None
@http.route()
def web_client(self, s_action=None, **kw):
ensure_db()
if not request.session.uid:
result = self._saml_autoredirect()
if result:
return result
return super().web_client(s_action, **kw)
@http.route()
def web_login(self, *args, **kw):
ensure_db()
if (
request.httprequest.method == "GET"
and request.session.uid
and request.params.get("redirect")
):
# Redirect if already logged in and redirect param is present
return request.redirect(request.params.get("redirect"))
if request.httprequest.method == "GET":
result = self._saml_autoredirect()
if result:
return result
providers = self.list_saml_providers()
response = super().web_login(*args, **kw)
if response.is_qweb:
error = request.params.get("saml_error")
if error == "no-signup":
error = _("Sign up is not allowed on this database.")
elif error == "access-denied":
error = _("Access Denied")
elif error == "expired":
error = _(
"You do not have access to this database. Please contact"
" support."
)
else:
error = None
response.qcontext["providers"] = providers
if error:
response.qcontext["error"] = error
return response
class AuthSAMLController(http.Controller):
def _get_saml_extra_relaystate(self):
"""
Compute any additional extra state to be sent to the IDP so it can
forward it back to us. This is called RelayState.
The provider will automatically set things like the dbname, provider
id, etc.
"""
redirect = request.params.get("redirect") or "web"
if not redirect.startswith(("//", "http://", "https://")):
redirect = "{}{}".format(
request.httprequest.url_root,
redirect[1:] if redirect[0] == "/" else redirect,
)
state = {
"r": url_quote_plus(redirect),
}
return state
@http.route("/auth_saml/get_auth_request", type="http", auth="none")
def get_auth_request(self, pid):
provider_id = int(pid)
provider = request.env["auth.saml.provider"].sudo().browse(provider_id)
redirect_url = provider._get_auth_request(
self._get_saml_extra_relaystate(), request.httprequest.url_root.rstrip("/")
)
if not redirect_url:
raise Exception(
"Failed to get auth request from provider. "
"Either misconfigured SAML provider or unknown provider."
)
redirect = werkzeug.utils.redirect(redirect_url, 303)
redirect.autocorrect_location_header = True
return redirect
@http.route("/auth_saml/signin", type="http", auth="none", csrf=False)
@fragment_to_query_string
# pylint: disable=unused-argument
def signin(self, req, **kw):
"""
Client obtained a saml token and passed it back
to us... we need to validate it
"""
saml_response = kw.get("SAMLResponse")
if kw.get("RelayState") is None:
# here we are in front of a client that went through
# some routes that "lost" its relaystate... this can happen
# if the client visited his IDP and successfully logged in
# then the IDP gave him a portal with his available applications
# but the provided link does not include the necessary relaystate
url = "/?type=signup"
redirect = werkzeug.utils.redirect(url, 303)
redirect.autocorrect_location_header = True
return redirect
state = json.loads(kw["RelayState"])
provider = state["p"]
dbname = state["d"]
context = state.get("c", {})
registry = registry_get(dbname)
with registry.cursor() as cr:
try:
env = api.Environment(cr, SUPERUSER_ID, context)
credentials = (
env["res.users"]
.sudo()
.auth_saml(
provider,
saml_response,
request.httprequest.url_root.rstrip("/"),
)
)
action = state.get("a")
menu = state.get("m")
url = "/"
if action:
url = "/#action=%s" % action
elif menu:
url = "/#menu_id=%s" % menu
return login_and_redirect(*credentials, redirect_url=url)
except odoo.exceptions.AccessDenied:
# saml credentials not valid,
# user could be on a temporary session
_logger.info("SAML2: access denied")
url = "/web/login?saml_error=expired"
redirect = werkzeug.utils.redirect(url, 303)
redirect.autocorrect_location_header = False
return redirect
except Exception as e:
# signup error
_logger.exception("SAML2: failure - %s", str(e))
url = "/web/login?saml_error=access-denied"
return set_cookie_and_redirect(url)
@http.route("/auth_saml/metadata", type="http", auth="none", csrf=False)
# pylint: disable=unused-argument
def saml_metadata(self, req, **kw):
provider = kw.get("p")
dbname = kw.get("d")
valid = kw.get("valid", None)
if not dbname or not provider:
_logger.debug("Metadata page asked without database name or provider id")
return request.not_found(_("Missing parameters"))
provider = int(provider)
registry = registry_get(dbname)
with registry.cursor() as cr:
env = api.Environment(cr, SUPERUSER_ID, {})
client = env["auth.saml.provider"].sudo().browse(provider)
if not client.exists():
return request.not_found(_("Unknown provider"))
return request.make_response(
client._metadata_string(
valid, request.httprequest.url_root.rstrip("/")
),
[("Content-Type", "text/xml")],
)
class Session(WebSession):
@http.route("/web/session/logout", type="http", auth="none")
def logout(self, redirect="/web/login"):
# make sure that when a user logs out, he does not get immediately
# relogged in if autoredirect is enabled, so that they get an
# opportunity to authenticate with a normal password and get access
# e.g. to the admin account.
if "disable_autoredirect" not in redirect:
path, sep, parameters = redirect.partition("?")
if parameters:
parameters += "&disable_autoredirect="
else:
parameters = "disable_autoredirect="
redirect = path + "?" + parameters
return super().logout(redirect=redirect)
| 35.317241 | 10,242 |
1,776 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Vault",
"summary": "Password vault integration in Odoo",
"license": "AGPL-3",
"version": "15.0.1.6.4",
"website": "https://github.com/OCA/server-auth",
"application": True,
"author": "initOS GmbH, Odoo Community Association (OCA)",
"category": "Vault",
"depends": ["base_setup", "web"],
"data": [
"security/ir.model.access.csv",
"security/ir_rule.xml",
"views/res_config_settings_views.xml",
"views/res_users_views.xml",
"views/vault_entry_views.xml",
"views/vault_field_views.xml",
"views/vault_file_views.xml",
"views/vault_log_views.xml",
"views/vault_inbox_views.xml",
"views/vault_right_views.xml",
"views/vault_views.xml",
"views/menuitems.xml",
"views/templates.xml",
"wizards/vault_export_wizard.xml",
"wizards/vault_import_wizard.xml",
"wizards/vault_send_wizard.xml",
"wizards/vault_store_wizard.xml",
],
"assets": {
"vault.assets_frontend": [
"vault/static/src/common/*.js",
"vault/static/src/frontend/*.js",
],
"web.assets_backend": [
"vault/static/lib/**/*.min.js",
"vault/static/src/common/*.js",
"vault/static/src/backend/*.scss",
"vault/static/src/backend/*.js",
"vault/static/src/legacy/vault_controller.js",
"vault/static/src/legacy/vault_widget.js",
],
"web.assets_qweb": [
"vault/static/src/**/*.xml",
],
"web.tests_assets": [
"vault/static/tests/**/*.js",
],
},
}
| 33.490566 | 1,775 |
5,897 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# Copyright 2022 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from datetime import datetime
from odoo.exceptions import ValidationError
from odoo.tests import TransactionCase
_logger = logging.getLogger(__name__)
class TestVault(TransactionCase):
def setUp(self):
super().setUp()
self.vault = self.env["vault"].create({"name": "Vault"})
self.entry = self.env["vault.entry"].create(
{"vault_id": self.vault.id, "name": "Entry"}
)
self.child = self.env["vault.entry"].create(
{"vault_id": self.vault.id, "name": "Child", "parent_id": self.entry.id}
)
def test_entry_path(self):
self.assertEqual(self.entry.complete_name, "Entry")
self.assertEqual(self.child.complete_name, "Entry / Child")
def test_wizard_actions(self):
values = self.child.action_open_import_wizard()
self.assertEqual(values["context"]["default_parent_id"], self.child.id)
values = self.vault.action_open_import_wizard()
self.assertNotIn("default_parent_id", values["context"])
values = self.child.action_open_export_wizard()
self.assertEqual(values["context"]["default_entry_id"], self.child.id)
values = self.vault.action_open_export_wizard()
self.assertNotIn("default_entry_id", values["context"])
def test_master_key(self):
right = self.vault.right_ids
self.assertEqual(self.vault.master_key, right.master_key)
self.vault.master_key = "test"
self.assertEqual(right.key, "test")
def test_share_public_key(self):
key = self.env["res.users.key"].create(
{
"user_id": self.vault.user_id.id,
"public": "a public key",
"salt": "42",
"iv": "2424",
"iterations": 4000,
"private": "24",
}
)
expected = {"user": 1, "public": key.public}
self.assertIn(expected, self.vault.share_public_keys())
def test_keys(self):
key = self.env["res.users.key"].create(
{
"user_id": self.vault.user_id.id,
"public": "a public key",
"salt": "42",
"iv": "2424",
"iterations": 4000,
"private": "24",
}
)
self.assertEqual(set("0123456789abcdef:"), set(key.fingerprint))
key.public = ""
self.assertEqual(key.fingerprint, False)
def test_store_keys(self):
model = self.env["res.users.key"]
# Raise some errors because of wrong parameters
with self.assertRaises(ValidationError):
model.store(1, "iv", "private", "public", 42, 42)
with self.assertRaises(ValidationError):
model.store(3000, "iv", "private", "public", "salt", 42)
with self.assertRaises(ValidationError):
model.store(4000, "iv", "private", "public", "salt", "abc")
# Actually store a new key
uuid = model.store(4000, "iv", "private", "public", "salt", 42)
rec = model.search([("uuid", "=", uuid)])
self.assertEqual(rec.private, "private")
self.assertTrue(rec.current)
# Don't store the same again
uuid = model.store(4000, "iv", "private", "public", "salt", 42)
self.assertFalse(uuid)
# Store a new one and disable the old one
uuid = model.store(4000, "iv", "more private", "public", "salt", 42)
self.assertFalse(rec.current)
rec = model.search([("uuid", "=", uuid)])
self.assertEqual(rec.private, "more private")
self.assertTrue(rec.current)
# Try to extract the public key again
user_id = self.env["res.users"].search([], limit=1, order="id DESC").id
public = model.extract_public_key(user_id + 1)
self.assertFalse(public)
public = model.extract_public_key(self.env.uid)
self.assertEqual(public, "public")
def test_vault_keys(self):
keys = self.env.user.get_vault_keys()
self.assertEqual(keys, {})
data = {
"user_id": self.env.user.id,
"public": "a public key",
"salt": "42",
"iv": "2424",
"iterations": 4000,
"private": "24",
}
self.env["res.users.key"].create(data)
keys = self.env.user.get_vault_keys()
for key in ["private", "public", "iv", "salt", "iterations"]:
self.assertEqual(keys[key], data[key])
def test_vault_entry_recursion(self):
child = self.env["vault.entry"].create(
{"vault_id": self.vault.id, "name": "Entry", "parent_id": self.entry.id}
)
with self.assertRaises(ValidationError):
self.entry.parent_id = child.id
def test_search_expired(self):
entry = self.env["vault.entry"]
self.assertEqual(entry._search_expired("in", []), [])
domain = entry._search_expired("=", True)
self.assertEqual(domain[0][:2], ("expire_date", "<"))
self.assertIsInstance(domain[0][2], datetime)
domain = entry._search_expired("!=", False)
self.assertEqual(domain[0][:2], ("expire_date", "<"))
self.assertIsInstance(domain[0][2], datetime)
domain = entry._search_expired("=", False)
self.assertTrue(domain[0] == "|")
self.assertIn(("expire_date", "=", False), domain)
self.assertTrue(any(("expire_date", ">=") == d[:2] for d in domain))
def test_vault_entry_search_panel_limit(self):
res = self.entry.search_panel_select_range("parent_id")
total_items = self.env["vault.entry"].search_count([("child_ids", "!=", False)])
self.assertEqual(len(res["values"]), total_items)
| 35.506024 | 5,894 |
1,841 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo.tests import TransactionCase
_logger = logging.getLogger(__name__)
class TestShare(TransactionCase):
def test_user_inbox(self):
user = self.env["res.users"].create(
{"login": "test", "email": "test@test", "name": "test"}
)
user.action_new_inbox_token()
model = self.env["res.users"]
token = user.inbox_token
self.assertEqual(user, model.find_user_of_inbox(token))
self.assertIn(token, user.inbox_link)
user.inbox_enabled = False
self.assertEqual(model, model.find_user_of_inbox(token))
user.action_new_inbox_token()
self.assertNotEqual(user.inbox_token, token)
def test_user_key_management(self):
action = self.env.ref("vault.action_res_users_keys")
self.assertEqual(action.id, self.env["res.users"].action_get_vault()["id"])
def test_invalidation(self):
self.env["res.users.key"].store(
40000, "invalid", "invalid", "invalid", "invalid", 42
)
self.assertTrue(self.env.user.keys.filtered("current"))
vault = self.env["vault"].create({"name": "Test"})
self.assertTrue(vault.right_ids)
inbox = self.env["vault.inbox"].create(
{
"name": "Inbox Test",
"secret": "secret",
"iv": "iv",
"user_id": self.env.uid,
"key": "key",
"secret_file": "",
"filename": "",
}
)
self.env.user.action_invalidate_key()
self.assertFalse(self.env.user.keys.filtered("current"))
self.assertFalse(inbox.exists())
self.assertFalse(vault.right_ids.exists())
| 30.666667 | 1,840 |
4,895 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo.exceptions import AccessError
from odoo.tests import TransactionCase
_logger = logging.getLogger(__name__)
class TestAccessRights(TransactionCase):
def setUp(self):
super().setUp()
self.user = self.env["res.users"].create(
{"login": "user", "name": "tester", "email": "user@localhost"}
)
self.vault = self.env["vault"].create({"name": "Vault"})
self.entry = self.env["vault.entry"].create(
{"vault_id": self.vault.id, "name": "Entry"}
)
self.field = self.env["vault.field"].create(
{"entry_id": self.entry.id, "name": "Field", "value": "Value"}
)
self.vault.right_ids.write({"key": "Owner"})
def test_public_key(self):
key = self.env["res.users.key"].create(
{
"user_id": self.vault.user_id.id,
"public": "a public key",
"salt": "42",
"iv": "2424",
"iterations": 4000,
"private": "24",
}
)
self.assertTrue(self.vault.right_ids.public_key)
self.assertEqual(key.public, self.vault.right_ids.public_key)
def test_owner_access(self):
# The owner can always access despite the permissions
for obj in [self.field, self.entry, self.vault]:
obj.name = "Owned"
right = self.vault.right_ids
right.perm_write = False
obj.name = "Owned"
right.perm_delete = False
obj.unlink()
def test_no_create(self):
self.env["vault.right"].create(
{
"vault_id": self.vault.id,
"user_id": self.user.id,
"perm_create": False,
}
)
for obj in [self.field, self.entry, self.vault]:
with self.assertRaises(AccessError):
obj.with_user(self.user).check_access_rule("create")
def test_no_right(self):
# No right defined for test user means access denied
for obj in [self.field, self.entry, self.vault]:
with self.assertRaises(AccessError):
self.assertTrue(obj.with_user(self.user).read())
with self.assertRaises(AccessError):
obj.with_user(self.user).name = "Owned"
with self.assertRaises(AccessError):
obj.with_user(self.user).unlink()
def test_no_permission(self):
# Defined right but no write permission means access denied
self.env["vault.right"].create(
{
"vault_id": self.vault.id,
"user_id": self.user.id,
"perm_create": False,
"perm_write": False,
"perm_delete": False,
}
)
for obj in [self.field, self.entry, self.vault]:
self.assertTrue(obj.with_user(self.user).read())
with self.assertRaises(AccessError):
obj.with_user(self.user).name = "Owned"
with self.assertRaises(AccessError):
obj.with_user(self.user).unlink()
def test_granted(self):
# Granted write permission allows writing
self.env["vault.right"].create(
{
"vault_id": self.vault.id,
"user_id": self.user.id,
"perm_write": True,
"perm_delete": True,
}
)
for obj in [self.field, self.entry, self.vault]:
self.assertTrue(obj.with_user(self.user).read())
obj.with_user(self.user).name = "Owned"
obj.with_user(self.user).unlink()
def test_owner_share(self):
self.env["vault.right"].create(
{"vault_id": self.vault.id, "user_id": self.user.id}
)
def test_user_share_no_right(self):
# No right defined means AccessError
with self.assertRaises(AccessError):
self.env["vault.right"].with_user(self.user).create(
{"vault_id": self.vault.id, "user_id": 2}
)
def test_user_share_no_permission(self):
# Created right but no permission to share
right = self.env["vault.right"].create(
{"vault_id": self.vault.id, "user_id": self.user.id, "perm_share": False}
)
with self.assertRaises(AccessError):
right.with_user(self.user).create({"vault_id": self.vault.id, "user_id": 2})
def test_user_share_granted(self):
# Granted permission to share
right = self.env["vault.right"].create(
{"vault_id": self.vault.id, "user_id": self.user.id, "perm_share": True}
)
right.with_user(self.user).create({"vault_id": self.vault.id, "user_id": 2})
right.unlink()
| 34.464789 | 4,894 |
3,514 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from datetime import datetime
from uuid import uuid4
from odoo.tests import TransactionCase
_logger = logging.getLogger(__name__)
class TestShare(TransactionCase):
def test_user_inbox(self):
user = self.env["res.users"].create(
{"login": "test", "email": "test@test", "name": "test"}
)
user.action_new_inbox_token()
model = self.env["res.users"]
token = user.inbox_token
self.assertEqual(user, model.find_user_of_inbox(token))
self.assertIn(token, user.inbox_link)
user.inbox_enabled = False
self.assertEqual(model, model.find_user_of_inbox(token))
user.action_new_inbox_token()
self.assertNotEqual(user.inbox_token, token)
def test_inbox(self):
model = self.env["vault.inbox"]
user = self.env.user
vals = {
"name": f"Inbox {user.name}",
"secret": "secret",
"iv": "iv",
"user": user,
"key": "key",
"secret_file": "",
"filename": "",
}
# Should create a new inbox for the user
inbox = model.store_in_inbox(**vals)
self.assertEqual(inbox.secret, "secret")
self.assertEqual(inbox.accesses, 0)
self.assertIn(inbox.token, inbox.inbox_link)
# No change because of no accesses left
vals["secret"] = "new secret"
inbox.store_in_inbox(**vals)
self.assertEqual(inbox.secret, "secret")
self.assertEqual(inbox.accesses, 0)
# Change expected because 5 accesses left
inbox.accesses = 5
inbox.store_in_inbox(**vals)
self.assertEqual(inbox.secret, "new secret")
self.assertEqual(inbox.accesses, 4)
# No change because expired
vals["secret"] = "newer secret"
inbox.expiration = datetime(1970, 1, 1)
inbox.store_in_inbox(**vals)
self.assertEqual(inbox.secret, "new secret")
self.assertEqual(inbox.accesses, 4)
# Search for shares
self.assertEqual(inbox, model.find_inbox(inbox.token))
self.assertEqual(model, model.find_inbox(uuid4()))
def test_send_wizard(self):
user = self.env.user
wiz = self.env["vault.send.wizard"].create(
{
"name": uuid4(),
"iv": "iv",
"key_user": "key",
"key": "k",
"secret": uuid4(),
"user_id": user.id,
}
)
# Create a new inbox
wiz.action_send()
self.assertTrue(self.env["vault.inbox"].search([("name", "=", wiz.name)]))
def test_store_wizard(self):
vault = self.env["vault"].create({"name": "Vault"})
entry = self.env["vault.entry"].create({"vault_id": vault.id, "name": "Entry"})
wiz = self.env["vault.store.wizard"].create(
{
"vault_id": vault.id,
"entry_id": entry.id,
"name": uuid4(),
"iv": "iv",
"key": "k",
"secret": uuid4(),
"secret_temporary": "temp",
"model": "vault.field",
}
)
vault.right_ids.write({"key": uuid4()})
self.assertEqual(wiz.master_key, vault.right_ids.key)
wiz.action_store()
self.assertEqual(wiz.name, entry.field_ids.name)
| 30.547826 | 3,513 |
1,449 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo.tests import TransactionCase
_logger = logging.getLogger(__name__)
class TestLog(TransactionCase):
def test_not_implemeneted(self):
with self.assertRaises(NotImplementedError):
self.env["vault.abstract"].log_entry("test")
with self.assertRaises(NotImplementedError):
self.env["vault.abstract"].log_info("test")
with self.assertRaises(NotImplementedError):
self.env["vault.abstract"].log_warn("test")
with self.assertRaises(NotImplementedError):
self.env["vault.abstract"].log_error("test")
def test_log_created(self):
vault = self.env["vault"].create({"name": "Vault"})
entry = self.env["vault.entry"].create({"vault_id": vault.id, "name": "Entry"})
vault.log_ids.unlink()
vault.log_info("info")
self.assertEqual(vault.log_ids.mapped("state"), ["info"])
self.assertEqual(entry.log_ids.mapped("state"), [])
entry.log_warn("warn")
self.assertEqual(vault.log_ids.mapped("state"), ["info", "warn"])
self.assertEqual(entry.log_ids.mapped("state"), ["warn"])
entry.log_error("error")
self.assertEqual(vault.log_ids.mapped("state"), ["info", "warn", "error"])
self.assertEqual(entry.log_ids.mapped("state"), ["warn", "error"])
| 35.317073 | 1,448 |
4,829 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import json
import logging
from uuid import uuid4
from odoo.exceptions import UserError
from odoo.tests import TransactionCase
_logger = logging.getLogger(__name__)
TestChild = {
"uuid": "42a",
"note": "test note child",
"name": "test child",
"url": "child.example.org",
"fields": [],
"files": [],
"childs": [],
}
TestData = [
{
"uuid": "42b",
"note": "test note child",
"name": "don't import",
"url": "child.example.org",
"fields": [],
"files": [],
"childs": [],
},
TestChild,
{
"uuid": "42",
"note": "test note",
"name": "test name",
"url": "test.example.org",
"fields": [
{"name": "a", "value": "Hello World", "iv": "abcd"},
{"name": "secret", "value": "dlrow olleh", "iv": "abcd"},
{"name": "secret", "value": "dlrow olle", "iv": "abcd"},
],
"files": [
{"name": "a", "value": "Hello World", "iv": "abcd"},
{"name": "secret", "value": "dlrow olleh", "iv": "abcd"},
{},
],
"childs": [
{
"uuid": "42aa",
"note": "test note subchild",
"name": "test subchild",
"url": "subchild.example.org",
"fields": [],
"files": [],
"childs": [],
},
TestChild,
],
},
TestChild,
]
class TestWidgets(TransactionCase):
def setUp(self):
super().setUp()
self.vault = self.env["vault"].create({"name": "Vault"})
self.entry = self.env["vault.entry"].create(
{"vault_id": self.vault.id, "name": "Entry"}
)
def test_path_generation(self):
wiz = self.env["vault.import.wizard"].create(
{"vault_id": self.vault.id, "crypted_content": json.dumps(TestData)}
)
wiz._onchange_content()
paths = wiz.path.search([("uuid", "=", wiz.uuid)]).mapped("name")
self.assertEqual(len(paths), 6)
self.assertIn("test name / test child", paths)
self.assertIn("test child", paths)
self.assertIn("test name", paths)
def test_import(self):
uuid = uuid4()
path = self.env["vault.import.wizard.path"].create(
{"name": "test", "uuid": uuid}
)
wiz = self.env["vault.import.wizard"].create(
{
"vault_id": self.vault.id,
"crypted_content": json.dumps(TestData),
"path": path.id,
"uuid": uuid,
}
)
wiz.action_import()
# We have duplicates
uuids = {"42", "42a", "42aa", self.entry.uuid}
self.assertSetEqual(set(self.vault.entry_ids.mapped("uuid")), uuids)
# Creation is depth-first which will cause the 42a to move up
self.assertEqual(self.vault.entry_ids.mapped("child_ids.uuid"), ["42aa"])
# This will cause an overwrite of the field
domain = [("entry_id.uuid", "=", "42"), ("name", "=", "secret")]
rec = self.env["vault.field"].search(domain)
self.assertEqual(rec.mapped("value"), ["dlrow olle"])
# Field with missing keys should fail
with self.assertRaises(UserError):
TestChild["fields"].append({"name": "12", "value": "eulav"})
wiz.crypted_content = json.dumps([TestChild])
wiz.action_import()
def test_export(self):
child = self.env["vault.entry"].create(
{"vault_id": self.vault.id, "name": "Child", "parent_id": self.entry.id}
)
second = self.env["vault.entry"].create(
{"vault_id": self.vault.id, "name": "second"}
)
wiz = self.env["vault.export.wizard"].create({"vault_id": self.vault.id})
# Export without entry should export entire vault
wiz._change_content()
entries = json.loads(wiz.content)
self.assertEqual({e["uuid"] for e in entries}, {second.uuid, self.entry.uuid})
self.assertEqual(len(entries), 2)
wiz.entry_id = self.entry
# Export the entire tree
wiz._change_content()
entries = json.loads(wiz.content)
self.assertEqual(len(entries), 1)
self.assertEqual(entries[0]["uuid"], self.entry.uuid)
self.assertEqual(entries[0]["childs"][0]["uuid"], child.uuid)
# Skip exporting childs
wiz.include_childs = False
wiz._change_content()
entries = json.loads(wiz.content)
self.assertEqual(len(entries), 1)
self.assertEqual(entries[0]["uuid"], self.entry.uuid)
self.assertEqual(len(entries[0]["childs"]), 0)
| 30.948718 | 4,828 |
6,884 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from unittest.mock import MagicMock
from odoo.tests import TransactionCase
from odoo.tools import mute_logger
from odoo.addons.website.tools import MockRequest
from ..controllers import main
_logger = logging.getLogger(__name__)
class TestController(TransactionCase):
def setUp(self):
super().setUp()
self.controller = main.Controller()
self.user = self.env["res.users"].create(
{"login": "test", "email": "test@test", "name": "test"}
)
self.user.inbox_token = "42"
self.user.keys.current = False
self.key = self.env["res.users.key"].create(
{
"user_id": self.user.id,
"public": "a public key",
"salt": "42",
"iv": "2424",
"iterations": 4000,
"private": "24",
"current": True,
}
)
self.inbox = self.env["vault.inbox"].create(
{
"user_id": self.user.id,
"name": "Inbox",
"key": "4",
"iv": "1",
"secret": "old secret",
"secret_file": "old file",
"accesses": 100,
}
)
@mute_logger("odoo.sql_db")
def test_vault_inbox(self):
def return_context(template, context):
self.assertEqual(template, "vault.inbox")
return context
with MockRequest(self.env) as request_mock:
request_mock.render = return_context
response = self.controller.vault_inbox("")
self.assertIn("error", response)
response = self.controller.vault_inbox(self.user.inbox_token)
self.assertNotIn("error", response)
self.assertEqual(response["public"], self.user.active_key.public)
# Try to eliminate each error step by step
request_mock.httprequest.method = "POST"
request_mock.params = {}
response = self.controller.vault_inbox(self.user.inbox_token)
self.assertIn("error", response)
request_mock.params["name"] = "test"
response = self.controller.vault_inbox(self.user.inbox_token)
self.assertIn("error", response)
request_mock.params.update(
{"encrypted": "secret", "encrypted_file": "file"}
)
response = self.controller.vault_inbox(self.user.inbox_token)
self.assertIn("error", response)
request_mock.params["filename"] = "filename"
response = self.controller.vault_inbox(self.user.inbox_token)
self.assertIn("error", response)
self.assertEqual(self.inbox.secret, "old secret")
self.assertEqual(self.inbox.secret_file, b"old file")
# Store something successfully
request_mock.params.update({"iv": "iv", "key": "key"})
response = self.controller.vault_inbox(self.inbox.token)
self.assertNotIn("error", response)
self.assertEqual(self.inbox.secret, "secret")
self.assertEqual(self.inbox.secret_file, b"file")
# Test a duplicate inbox
self.inbox.copy().token = self.inbox.token
response = self.controller.vault_inbox(self.inbox.token)
self.assertIn("error", response)
def raise_error(*args, **kwargs):
raise TypeError()
# Catch internal errors
try:
request_mock.httprequest.remote_addr = "127.0.0.1"
self.env["vault.inbox"]._patch_method("store_in_inbox", raise_error)
response = self.controller.vault_inbox(self.user.inbox_token)
finally:
self.env["vault.inbox"]._revert_method("store_in_inbox")
self.assertIn("error", response)
@mute_logger("odoo.sql_db")
def test_vault_public(self):
with MockRequest(self.env):
no_key = self.env["res.users"].create(
{"login": "keyless", "email": "test@test", "name": "test"}
)
response = self.controller.vault_public(user_id=no_key.id)
self.assertEqual(response, {})
response = self.controller.vault_public(user_id=self.user.id)
self.assertEqual(response["public_key"], self.key.public)
@mute_logger("odoo.sql_db")
def test_vault_store(
self,
):
with MockRequest(self.env):
mock = MagicMock()
try:
self.env["res.users.key"]._patch_method("store", mock)
self.controller.vault_store_keys()
mock.assert_called_once()
finally:
self.env["res.users.key"]._revert_method("store")
@mute_logger("odoo.sql_db")
def test_vault_keys_get(self):
with MockRequest(self.env):
mock = MagicMock()
try:
self.env["res.users"]._patch_method("get_vault_keys", mock)
self.controller.vault_get_keys()
mock.assert_called_once()
finally:
self.env["res.users"]._revert_method("get_vault_keys")
@mute_logger("odoo.sql_db")
def test_vault_right_keys(self):
with MockRequest(self.env):
self.assertFalse(self.controller.vault_get_right_keys())
# New vault with user as owner and only right
vault = self.env["vault"].create({"name": "Vault"})
response = self.controller.vault_get_right_keys()
self.assertEqual(response, {vault.uuid: vault.right_ids.key})
@mute_logger("odoo.sql_db")
def test_vault_store_right_key(self):
with MockRequest(self.env):
vault = self.env["vault"].create({"name": "Vault"})
self.controller.vault_store_right_keys(None)
self.controller.vault_store_right_keys({vault.uuid: "new key"})
self.assertEqual(vault.right_ids.key, "new key")
@mute_logger("odoo.sql_db")
def test_vault_inbox_keys(self):
with MockRequest(self.env):
self.assertFalse(self.controller.vault_get_inbox())
inbox = self.inbox.copy({"user_id": self.env.uid})
response = self.controller.vault_get_inbox()
self.assertEqual(response, {inbox.token: inbox.key})
@mute_logger("odoo.sql_db")
def test_vault_store_inbox_key(self):
with MockRequest(self.env):
inbox = self.inbox.copy({"user_id": self.env.uid})
inbox.user_id = self.env.user
self.controller.vault_store_inbox(None)
self.controller.vault_store_inbox({inbox.token: "new key"})
self.assertEqual(inbox.key, "new key")
| 36.036649 | 6,883 |
417 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import _, fields, models
_logger = logging.getLogger(__name__)
class VaultField(models.Model):
_name = "vault.field"
_description = _("Field of a vault")
_order = "name"
_inherit = ["vault.abstract.field", "vault.abstract"]
value = fields.Char(required=True)
| 24.470588 | 416 |
1,237 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import _, api, fields, models
_logger = logging.getLogger(__name__)
class VaultLog(models.Model):
_name = "vault.log"
_description = _("Log entry of a vault")
_order = "create_date DESC"
_rec_name = "message"
vault_id = fields.Many2one(
"vault",
"Vault",
ondelete="cascade",
required=True,
readonly=True,
)
entry_id = fields.Many2one(
"vault.entry",
"Entry",
ondelete="cascade",
readonly=True,
)
user_id = fields.Many2one("res.users", "User", required=True, readonly=True)
state = fields.Selection(lambda self: self._get_log_state(), readonly=True)
message = fields.Char(readonly=True, required=True)
def _get_log_state(self):
return [
("info", _("Information")),
("warn", _("Warning")),
("error", _("Error")),
]
@api.model
def create(self, values):
res = super().create(values)
if not self.env.context.get("skip_log", False):
_logger.info("Vault log: %s", res.message)
return res
| 26.869565 | 1,236 |
718 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import _, api, fields, models
_logger = logging.getLogger(__name__)
class VaultFile(models.Model):
_name = "vault.file"
_description = _("File of a vault")
_order = "name"
_inherit = ["vault.abstract.field", "vault.abstract"]
value = fields.Binary(attachment=False)
@api.model
def search_read(self, *args, **kwargs):
if self.env.context.get("vault_reencrypt"):
return super(VaultFile, self.with_context(bin_size=False)).search_read(
*args, **kwargs
)
return super().search_read(*args, **kwargs)
| 28.68 | 717 |
3,394 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
class VaultRight(models.Model):
_name = "vault.right"
_description = _("Vault rights")
_inherit = ["vault.abstract"]
_order = "user_id"
vault_id = fields.Many2one(
"vault",
"Vault",
readonly=True,
required=True,
ondelete="cascade",
)
master_key = fields.Char(related="vault_id.master_key", readonly=True, store=False)
user_id = fields.Many2one(
"res.users",
"User",
domain=[("keys", "!=", False)],
required=True,
)
public_key = fields.Char(compute="_compute_public_key", readonly=True, store=False)
perm_create = fields.Boolean(
"Create",
default=lambda self: self._get_is_owner(),
help="Allow to create in the vault",
)
perm_write = fields.Boolean(
"Write",
default=lambda self: self._get_is_owner(),
help="Allow to write to the vault",
)
perm_share = fields.Boolean(
"Share",
default=lambda self: self._get_is_owner(),
help="Allow to share a vault with new users",
)
perm_delete = fields.Boolean(
"Delete",
default=lambda self: self._get_is_owner(),
help="Allow to delete a vault",
)
perm_user = fields.Many2one(related="vault_id.perm_user", store=False)
allowed_read = fields.Boolean(related="vault_id.allowed_read", store=False)
allowed_create = fields.Boolean(related="vault_id.allowed_create", store=False)
allowed_write = fields.Boolean(related="vault_id.allowed_write", store=False)
allowed_share = fields.Boolean(related="vault_id.allowed_share", store=False)
allowed_delete = fields.Boolean(related="vault_id.allowed_delete", store=False)
# Encrypted with the public key of the user
key = fields.Char()
_sql_constraints = (
("user_uniq", "UNIQUE(user_id, vault_id)", _("The user must be unique")),
)
def _get_is_owner(self):
return self.env.user == self.vault_id.user_id
@api.depends("user_id")
def _compute_public_key(self):
for rec in self:
rec.public_key = rec.user_id.active_key.public
def log_access(self):
self.ensure_one()
rights = ", ".join(
sorted(
["read"]
+ [
right
for right in ["create", "write", "share", "delete"]
if getattr(self, f"perm_{right}", False)
]
)
)
self.vault_id.log_info(
f"Grant access to user {self.user_id.display_name}: {rights}"
)
@api.model
def create(self, values):
res = super().create(values)
if not res.allowed_share and not res.env.su:
self.raise_access_error()
res.log_access()
return res
def write(self, values):
res = super().write(values)
perms = ["perm_write", "perm_delete", "perm_share", "perm_create"]
if any(x in values for x in perms):
for rec in self:
rec.log_access()
return res
def unlink(self):
for rec in self:
rec.vault_id.log_info(f"Removed user {self.user_id.display_name}")
return super().unlink()
| 30.845455 | 3,393 |
5,371 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from uuid import uuid4
from odoo import _, api, fields, models
_logger = logging.getLogger(__name__)
class Vault(models.Model):
_name = "vault"
_description = _("Vault")
_inherit = ["vault.abstract"]
_order = "name"
user_id = fields.Many2one(
"res.users",
"Owner",
readonly=True,
default=lambda self: self.env.user,
required=True,
)
right_ids = fields.One2many(
"vault.right",
"vault_id",
"Rights",
default=lambda self: self._get_default_rights(),
)
entry_ids = fields.One2many("vault.entry", "vault_id", "Entries")
field_ids = fields.One2many("vault.field", "vault_id", "Fields")
file_ids = fields.One2many("vault.file", "vault_id", "Files")
log_ids = fields.One2many("vault.log", "vault_id", "Log", readonly=True)
# Access control
perm_user = fields.Many2one("res.users", compute="_compute_access", store=False)
allowed_read = fields.Boolean(compute="_compute_access", store=False)
allowed_create = fields.Boolean(compute="_compute_access", store=False)
allowed_share = fields.Boolean(compute="_compute_access", store=False)
allowed_write = fields.Boolean(compute="_compute_access", store=False)
allowed_delete = fields.Boolean(compute="_compute_access", store=False)
master_key = fields.Char(
compute="_compute_master_key",
inverse="_inverse_master_key",
store=False,
)
uuid = fields.Char(default=lambda self: uuid4(), required=True, readonly=True)
name = fields.Char(required=True)
note = fields.Text()
_sql_constraints = [
("uuid_uniq", "UNIQUE(uuid)", _("The UUID must be unique.")),
]
@api.depends("right_ids.user_id")
def _compute_access(self):
user = self.env.user
for rec in self.sudo():
rec.perm_user = user.id
if user == rec.user_id:
rec.write(
{
"allowed_create": True,
"allowed_share": True,
"allowed_write": True,
"allowed_delete": True,
"allowed_read": True,
}
)
continue
rights = rec.right_ids
rec.allowed_read = user in rights.mapped("user_id")
rec.allowed_create = user in rights.filtered("perm_create").mapped(
"user_id"
)
rec.allowed_share = user in rights.filtered("perm_share").mapped("user_id")
rec.allowed_write = user in rights.filtered("perm_write").mapped("user_id")
rec.allowed_delete = user in rights.filtered("perm_delete").mapped(
"user_id"
)
@api.depends("right_ids.key")
def _compute_master_key(self):
domain = [("user_id", "=", self.env.uid)]
for rec in self:
rights = rec.right_ids.filtered_domain(domain)
rec.master_key = rights[0].key if rights else False
def _inverse_master_key(self):
domain = [("user_id", "=", self.env.uid)]
for rec in self:
rights = rec.right_ids.filtered_domain(domain)
if rights and not rights.key:
rights.key = rec.master_key
def _get_default_rights(self):
return [
(
0,
0,
{
"user_id": self.env.uid,
"perm_create": True,
"perm_write": True,
"perm_delete": True,
"perm_share": True,
},
)
]
def _log_entry(self, msg, state):
self.ensure_one()
return (
self.env["vault.log"]
.sudo()
.create(
{
"vault_id": self.id,
"user_id": self.env.uid,
"message": msg,
"state": state,
}
)
)
def share_public_keys(self):
self.ensure_one()
result = []
for right in self.right_ids:
result.append({"user": right.user_id.id, "public": right.public_key})
return result
def action_open_import_wizard(self):
self.ensure_one()
wizard = self.env.ref("vault.view_vault_import_wizard")
return {
"name": _("Import from file"),
"type": "ir.actions.act_window",
"view_mode": "form",
"res_model": "vault.import.wizard",
"views": [(wizard.id, "form")],
"view_id": wizard.id,
"target": "new",
"context": {"default_vault_id": self.id},
}
def action_open_export_wizard(self):
self.ensure_one()
wizard = self.env.ref("vault.view_vault_export_wizard")
return {
"name": _("Export to file"),
"type": "ir.actions.act_window",
"view_mode": "form",
"res_model": "vault.export.wizard",
"views": [(wizard.id, "form")],
"view_id": wizard.id,
"target": "new",
"context": {"default_vault_id": self.id},
}
| 32.743902 | 5,370 |
3,575 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from datetime import datetime, timedelta
from uuid import uuid4
from odoo import _, api, fields, models
_logger = logging.getLogger(__name__)
class VaultInbox(models.Model):
_name = "vault.inbox"
_description = _("Vault share incoming secrets")
token = fields.Char(default=lambda self: uuid4(), readonly=True, copy=False)
inbox_link = fields.Char(
compute="_compute_inbox_link",
readonly=True,
help="Using this link you can write to the current inbox. If you want people "
"to create new inboxes you should give them your inbox link from your key "
"management.",
)
user_id = fields.Many2one(
"res.users",
"Vault",
required=True,
)
name = fields.Char(required=True)
secret = fields.Char(readonly=True)
filename = fields.Char()
secret_file = fields.Binary(attachment=False, readonly=True)
key = fields.Char(required=True)
iv = fields.Char(required=True)
accesses = fields.Integer(
"Access counter",
default=1,
help="If this is 0 the inbox can't be written using the link",
)
expiration = fields.Datetime(
default=lambda self: datetime.now() + timedelta(days=7),
help="If expired the inbox can't be written using the link",
)
log_ids = fields.One2many("vault.inbox.log", "inbox_id", "Log", readonly=True)
_sql_constraints = [
(
"value_check",
"CHECK(secret IS NOT NULL OR secret_file IS NOT NULL)",
_("No value found"),
),
]
@api.depends("token")
def _compute_inbox_link(self):
base_url = self.env["ir.config_parameter"].sudo().get_param("web.base.url")
for rec in self:
rec.inbox_link = f"{base_url}/vault/inbox/{rec.token}"
def read(self, *args, **kwargs):
# Always load the binary instead of the size
return super(VaultInbox, self.with_context(bin_size=False)).read(
*args, **kwargs
)
@api.model
def find_inbox(self, token):
return self.search([("token", "=", token)])
def store_in_inbox(
self,
name,
secret,
secret_file,
iv,
key,
user,
filename,
ip=None,
):
log_info = {"name": user.name, "ip": ip or "n/a"}
if len(self) == 0:
log = _("Created by %(name)s via %(ip)s") % log_info
return self.create(
{
"name": name,
"accesses": 0,
"iv": iv,
"key": key,
"secret": secret or None,
"secret_file": secret_file or None,
"filename": filename,
"user_id": user.id,
"log_ids": [(0, 0, {"name": log})],
}
)
self.ensure_one()
if self.accesses > 0 and datetime.now() < self.expiration:
log = _("Written by %(name)s via %(ip)s") % log_info
self.write(
{
"accesses": self.accesses - 1,
"iv": iv,
"key": key,
"secret": secret or None,
"secret_file": secret_file or None,
"filename": filename,
"log_ids": [(0, 0, {"name": log})],
}
)
return self
| 31.350877 | 3,574 |
2,820 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
import re
from hashlib import sha256
from uuid import uuid4
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
_logger = logging.getLogger(__name__)
class ResUsersKey(models.Model):
_name = "res.users.key"
_description = _("User data of a vault")
_rec_name = "fingerprint"
_order = "create_date DESC"
user_id = fields.Many2one("res.users", required=True)
uuid = fields.Char(default=lambda self: uuid4(), required=True, readonly=True)
current = fields.Boolean(default=True, readonly=True)
fingerprint = fields.Char(compute="_compute_fingerprint", store=True)
public = fields.Char(required=True, readonly=True)
salt = fields.Char(required=True, readonly=True)
iv = fields.Char(required=True, readonly=True)
iterations = fields.Integer(required=True, readonly=True)
version = fields.Integer(readonly=True)
# Encrypted with master password of user
private = fields.Char(required=True, readonly=True)
@api.depends("public")
def _compute_fingerprint(self):
for rec in self:
if rec.public:
hashed = sha256(rec.public.encode()).hexdigest()
rec.fingerprint = ":".join(re.findall(r".{2}", hashed))
else:
rec.fingerprint = False
def _prepare_values(self, iterations, iv, private, public, salt, version):
return {
"iterations": iterations,
"iv": iv,
"private": private,
"public": public,
"salt": salt,
"user_id": self.env.uid,
"current": True,
"version": version,
}
def store(self, iterations, iv, private, public, salt, version):
if not all(isinstance(x, str) and x for x in [public, private, iv, salt]):
raise ValidationError(_("Invalid parameter"))
if not isinstance(iterations, int) or iterations < 4000:
raise ValidationError(_("Invalid parameter"))
if not isinstance(version, int):
raise ValidationError(_("Invalid parameter"))
domain = [
("user_id", "=", self.env.uid),
("private", "=", private),
]
key = self.search(domain)
if not key:
# Disable all current keys
self.env.user.keys.write({"current": False})
rec = self.create(
self._prepare_values(iterations, iv, private, public, salt, version)
)
return rec.uuid
return False
def extract_public_key(self, user):
user = self.sudo().search([("user_id", "=", user), ("current", "=", True)])
return user.public or None
| 34.378049 | 2,819 |
6,710 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# Copyright 2022 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from datetime import datetime
from uuid import uuid4
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
_logger = logging.getLogger(__name__)
class VaultEntry(models.Model):
_name = "vault.entry"
_description = _("Entry inside a vault")
_inherit = ["vault.abstract"]
_order = "complete_name"
_rec_name = "complete_name"
parent_id = fields.Many2one(
"vault.entry",
"Parent",
ondelete="cascade",
domain="[('vault_id', '=', vault_id)]",
)
child_ids = fields.One2many("vault.entry", "parent_id", "Child")
vault_id = fields.Many2one("vault", "Vault", ondelete="cascade", required=True)
user_id = fields.Many2one(related="vault_id.user_id")
field_ids = fields.One2many("vault.field", "entry_id", "Fields")
file_ids = fields.One2many("vault.file", "entry_id", "Files")
log_ids = fields.One2many("vault.log", "entry_id", "Log", readonly=True)
perm_user = fields.Many2one(related="vault_id.perm_user", store=False)
allowed_read = fields.Boolean(related="vault_id.allowed_read", store=False)
allowed_create = fields.Boolean(related="vault_id.allowed_create", store=False)
allowed_share = fields.Boolean(related="vault_id.allowed_share", store=False)
allowed_write = fields.Boolean(related="vault_id.allowed_write", store=False)
allowed_delete = fields.Boolean(related="vault_id.allowed_delete", store=False)
complete_name = fields.Char(
compute="_compute_complete_name",
store=True,
readonly=True,
recursive=True,
)
uuid = fields.Char(default=lambda self: uuid4(), required=True)
name = fields.Char(required=True)
url = fields.Char()
note = fields.Text()
tags = fields.Many2many("vault.tag")
expire_date = fields.Datetime("Expires on", default=False)
expired = fields.Boolean(
compute="_compute_expired",
search="_search_expired",
store=False,
)
_sql_constraints = [
("vault_uuid_uniq", "UNIQUE(vault_id, uuid)", _("The UUID must be unique.")),
]
@api.constrains("parent_id")
def _check_parent_id(self):
if not self._check_recursion():
raise ValidationError(_("You can not create recursive entries."))
@api.depends("name", "parent_id.complete_name")
def _compute_complete_name(self):
for rec in self:
if rec.parent_id:
rec.complete_name = f"{rec.parent_id.complete_name} / {rec.name}"
else:
rec.complete_name = rec.name
@api.model
def search_panel_select_range(self, field_name, **kwargs):
"""We add the following contexts related to searchpanel:
- entry_short_name: Show just the name instead of full path.
- from_search_panel: It will be used to overwrite domain.
Remove the limit of records (default is 200).
"""
return super(
VaultEntry,
self.with_context(from_search_panel=True, entry_short_name=True),
).search_panel_select_range(field_name, **kwargs)
def search_read(self, domain=None, fields=None, offset=0, limit=None, order=None):
"""Changes related to searchpanel:
- Add a domain to only show records with children.
"""
domain = domain if domain else []
if self.env.context.get("from_search_panel"):
domain += [("child_ids", "!=", False)]
return super().search_read(
domain=domain, fields=fields, offset=offset, limit=limit, order=order
)
@api.depends("name", "complete_name")
def _compute_display_name(self):
if not self.env.context.get("entry_short_name", False):
return super()._compute_display_name()
for record in self:
record.display_name = record.name
@api.depends("expire_date")
def _compute_expired(self):
now = datetime.now()
for rec in self:
rec.expired = rec.expire_date and now > rec.expire_date
def _search_expired(self, operator, value):
if (operator not in ["=", "!="]) or (value not in [True, False]):
return []
if (operator, value) in [("=", True), ("!=", False)]:
return [("expire_date", "<", datetime.now())]
return ["|", ("expire_date", ">=", datetime.now()), ("expire_date", "=", False)]
def log_change(self, action):
self.ensure_one()
self.log_info(
_("%(action)s entry %(name)s by %(user)s")
% {
"action": action,
"name": self.complete_name,
"user": self.env.user.display_name,
}
)
@api.model_create_single
def create(self, values):
res = super().create(values)
res.log_change("Created")
return res
def unlink(self):
for rec in self:
rec.log_change("Deleted")
return super().unlink()
def _log_entry(self, msg, state):
self.ensure_one()
return (
self.env["vault.log"]
.sudo()
.create(
{
"vault_id": self.vault_id.id,
"entry_id": self.id,
"user_id": self.env.uid,
"message": msg,
"state": state,
}
)
)
def action_open_import_wizard(self):
self.ensure_one()
wizard = self.env.ref("vault.view_vault_import_wizard")
return {
"name": _("Import from file"),
"type": "ir.actions.act_window",
"view_mode": "form",
"res_model": "vault.import.wizard",
"views": [(wizard.id, "form")],
"view_id": wizard.id,
"target": "new",
"context": {
"default_vault_id": self.vault_id.id,
"default_parent_id": self.id,
},
}
def action_open_export_wizard(self):
self.ensure_one()
wizard = self.env.ref("vault.view_vault_export_wizard")
return {
"name": _("Export to file"),
"type": "ir.actions.act_window",
"view_mode": "form",
"res_model": "vault.export.wizard",
"views": [(wizard.id, "form")],
"view_id": wizard.id,
"target": "new",
"context": {
"default_vault_id": self.vault_id.id,
"default_entry_id": self.id,
},
}
| 34.572165 | 6,707 |
2,605 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from uuid import uuid4
from odoo import api, fields, models
_logger = logging.getLogger(__name__)
class ResUsers(models.Model):
_inherit = "res.users"
active_key = fields.Many2one(
"res.users.key",
compute="_compute_active_key",
store=False,
)
keys = fields.One2many("res.users.key", "user_id", readonly=True)
vault_right_ids = fields.One2many("vault.right", "user_id", readonly=True)
inbox_ids = fields.One2many("vault.inbox", "user_id")
inbox_enabled = fields.Boolean(default=True)
inbox_link = fields.Char(compute="_compute_inbox_link", readonly=True, store=False)
inbox_token = fields.Char(default=lambda self: uuid4(), readonly=True)
@api.depends("keys", "keys.current")
def _compute_active_key(self):
for rec in self:
keys = rec.sudo().keys.filtered("current")
rec.active_key = keys[0] if keys else None
@api.depends("inbox_token")
def _compute_inbox_link(self):
base_url = self.env["ir.config_parameter"].sudo().get_param("web.base.url")
for rec in self:
rec.inbox_link = f"{base_url}/vault/inbox/{rec.inbox_token}"
@api.model
def action_get_vault(self):
action = self.sudo().env.ref("vault.action_res_users_keys")
result = action.read()[0]
result["res_id"] = self.env.uid
return result
def action_new_inbox_token(self):
self.ensure_one()
self.sudo().inbox_token = uuid4()
return self.action_get_vault()
def action_invalidate_key(self):
"""Disable the current key and remove all accesses to the vaults"""
self.ensure_one()
self.keys.write({"current": False})
self.vault_right_ids.sudo().unlink()
self.inbox_ids.unlink()
self.env["vault"].search([])._compute_access()
return self.action_get_vault()
@api.model
def find_user_of_inbox(self, token):
return self.search([("inbox_token", "=", token), ("inbox_enabled", "=", True)])
def get_vault_keys(self):
self.ensure_one()
if not self.active_key:
return {}
return {
"iterations": self.active_key.iterations,
"iv": self.active_key.iv,
"private": self.active_key.private,
"public": self.active_key.public,
"salt": self.active_key.salt,
"uuid": self.active_key.uuid,
"version": self.active_key.version,
}
| 33.384615 | 2,604 |
1,922 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import _, api, fields, models
_logger = logging.getLogger(__name__)
class AbstractVaultField(models.AbstractModel):
_name = "vault.abstract.field"
_description = _("Abstract model to implement basic fields for encryption")
entry_id = fields.Many2one("vault.entry", ondelete="cascade", required=True)
vault_id = fields.Many2one(related="entry_id.vault_id")
master_key = fields.Char(compute="_compute_master_key", store=False)
perm_user = fields.Many2one(related="vault_id.perm_user", store=False)
allowed_read = fields.Boolean(related="vault_id.allowed_read", store=False)
allowed_create = fields.Boolean(related="vault_id.allowed_create", store=False)
allowed_write = fields.Boolean(related="vault_id.allowed_write", store=False)
allowed_share = fields.Boolean(related="vault_id.allowed_share", store=False)
allowed_delete = fields.Boolean(related="vault_id.allowed_delete", store=False)
name = fields.Char(required=True)
iv = fields.Char()
@api.depends("entry_id.vault_id.master_key")
def _compute_master_key(self):
for rec in self:
rec.master_key = rec.vault_id.master_key
def log_change(self, action):
self.ensure_one()
self.entry_id.log_info(
f"{action} value {self.name} of {self.entry_id.complete_name} "
f"by {self.env.user.display_name}"
)
@api.model_create_single
def create(self, values):
res = super().create(values)
res.log_change("Created")
return res
def unlink(self):
for rec in self:
rec.log_change("Deleted")
return super().unlink()
def write(self, values):
for rec in self:
rec.log_change("Changed")
return super().write(values)
| 33.701754 | 1,921 |
270 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
module_vault_share = fields.Boolean()
| 26.9 | 269 |
511 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import _, fields, models
_logger = logging.getLogger(__name__)
class VaultInboxLog(models.Model):
_name = "vault.inbox.log"
_description = _("Vault inbox log")
_order = "create_date DESC"
inbox_id = fields.Many2one(
"vault.inbox",
ondelete="cascade",
readonly=True,
required=True,
)
name = fields.Char(readonly=True)
| 23.181818 | 510 |
2,546 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import _, api, models
from odoo.exceptions import AccessError
_logger = logging.getLogger(__name__)
class AbstractVault(models.AbstractModel):
"""Models must have the following fields:
`perm_user`: The permissions are computed for this user
`allowed_read`: The current user can read from the vault
`allowed_create`: The current user can read from the vault
`allowed_write`: The current user has write access to the vault
`allowed_share`: The current user can share the vault with other users
`allowed_delete`: The current user can delete the vault or entries of it
"""
_name = "vault.abstract"
_description = _("Abstract model to implement general access rights")
@api.model
def raise_access_error(self):
raise AccessError(
_(
"The requested operation can not be completed due to security "
"restrictions."
)
)
def check_access_rule(self, operation):
super().check_access_rule(operation)
if self.env.su:
return
# We have to recompute if the user of the environment changed
if self.env.user != self.mapped("perm_user"):
vault = self if self._name == "vault" else self.mapped("vault_id")
vault._compute_access()
# Shortcut for vault.right because only the share right is required
if self._name == "vault.right":
if not self.filtered("allowed_share"):
self.raise_access_error()
return
# Check the operation and matching permissions
if operation == "read" and not self.filtered("allowed_read"):
self.raise_access_error()
if operation == "create" and not self.filtered("allowed_create"):
self.raise_access_error()
if operation == "write" and not self.filtered("allowed_write"):
self.raise_access_error()
if operation == "unlink" and not self.filtered("allowed_delete"):
self.raise_access_error()
def _log_entry(self, msg, state):
raise NotImplementedError()
def log_entry(self, msg):
return self._log_entry(msg, None)
def log_info(self, msg):
return self._log_entry(msg, "info")
def log_warn(self, msg):
return self._log_entry(msg, "warn")
def log_error(self, msg):
return self._log_entry(msg, "error")
| 33.051948 | 2,545 |
393 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, fields, models
class VaultTag(models.Model):
_name = "vault.tag"
_description = _("Vault tag")
_order = "name"
name = fields.Char(required=True)
_sql_constraints = [
("name_uniq", "unique(name)", _("The tag must be unique!")),
]
| 24.5 | 392 |
1,540 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import _, fields, models
_logger = logging.getLogger(__name__)
class VaultSendWizard(models.TransientModel):
_name = "vault.send.wizard"
_description = _("Wizard to send another user a secret")
user_id = fields.Many2one(
"res.users",
"User",
required=True,
domain=[("keys", "!=", False), ("inbox_enabled", "=", True)],
)
name = fields.Char(required=True)
public = fields.Char(related="user_id.active_key.public")
iv = fields.Char(required=True)
key_user = fields.Char(required=True)
key = fields.Char(required=True)
secret = fields.Char(required=True)
secret_file = fields.Char()
filename = fields.Char()
_sql_constraints = [
(
"value_check",
"CHECK(secret IS NOT NULL OR secret_file IS NOT NULL)",
_("No value found"),
),
]
def action_send(self):
self.ensure_one()
self.env["vault.inbox"].sudo().create(
{
"name": self.name,
"accesses": 0,
"secret": self.secret,
"secret_file": self.secret_file,
"iv": self.iv,
"key": self.key_user,
"user_id": self.user_id.id,
"filename": self.filename,
"log_ids": [(0, 0, {"name": _("Created by %s") % self.user_id.name})],
}
)
| 29.596154 | 1,539 |
1,420 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import _, api, fields, models
_logger = logging.getLogger(__name__)
class VaultStoreWizard(models.TransientModel):
_name = "vault.store.wizard"
_description = _("Wizard store a shared secret in a vault")
vault_id = fields.Many2one("vault", "Vault", required=True)
entry_id = fields.Many2one(
"vault.entry",
"Entry",
domain="[('vault_id', '=', vault_id)]",
required=True,
)
model = fields.Char(required=True)
master_key = fields.Char(compute="_compute_master_key", store=False)
name = fields.Char(required=True)
iv = fields.Char(required=True)
key = fields.Char(required=True)
secret = fields.Char(required=True)
secret_temporary = fields.Char(required=True)
@api.depends("entry_id", "vault_id")
def _compute_master_key(self):
for rec in self:
rec.master_key = rec.vault_id.master_key
def action_store(self):
self.ensure_one()
try:
self.env[self.model].create(
{
"entry_id": self.entry_id.id,
"name": self.name,
"iv": self.iv,
"value": self.secret,
}
)
except Exception as e:
_logger.exception(e)
| 30.191489 | 1,419 |
2,022 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import json
import logging
from datetime import datetime
from odoo import _, api, fields, models
_logger = logging.getLogger(__name__)
class ExportWizard(models.TransientModel):
_name = "vault.export.wizard"
_description = _("Export wizard for vaults")
vault_id = fields.Many2one("vault", "Vault")
entry_id = fields.Many2one(
"vault.entry", "Entries", domain="[('vault_id', '=', vault_id)]"
)
master_key = fields.Char(related="vault_id.master_key")
name = fields.Char(default=lambda self: self._default_name())
content = fields.Binary("Download", attachment=False)
include_childs = fields.Boolean(default=True)
@api.onchange("vault_id", "entry_id")
def _change_content(self):
for rec in self.with_context(skip_log=True):
if rec.entry_id:
entries = rec.entry_id
else:
entries = rec.vault_id.entry_ids.filtered_domain(
[("parent_id", "=", False)]
)
data = [rec._export_entry(x) for x in entries]
rec.content = json.dumps(data)
def _default_name(self):
return datetime.now().strftime("database-%Y%m%d-%H%M.json")
@api.model
def _export_field(self, rec):
def ensure_string(x):
return x.decode() if isinstance(x, bytes) else x
return {f: ensure_string(rec[f]) for f in ["name", "iv", "value"]}
def _export_entry(self, entry):
if self.include_childs:
childs = [self._export_entry(x) for x in entry.child_ids]
else:
childs = []
return {
"uuid": entry.uuid,
"name": entry.name,
"note": entry.note,
"url": entry.url,
"fields": entry.field_ids.mapped(self._export_field),
"files": entry.file_ids.mapped(self._export_field),
"childs": childs,
}
| 32.079365 | 2,021 |
4,315 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import json
import logging
from uuid import uuid4
from odoo import _, api, fields, models
from odoo.exceptions import UserError
_logger = logging.getLogger(__name__)
class ImportWizardPath(models.TransientModel):
_name = "vault.import.wizard.path"
_description = _("Import wizard path for vaults")
name = fields.Char(required=True)
uuid = fields.Char(required=True)
class ImportWizard(models.TransientModel):
_name = "vault.import.wizard"
_description = _("Import wizard for vaults")
vault_id = fields.Many2one("vault", "Vault")
parent_id = fields.Many2one(
"vault.entry",
"Parent Entry",
domain="[('vault_id', '=', vault_id)]",
)
master_key = fields.Char(related="vault_id.master_key")
name = fields.Char()
content = fields.Binary("Database", attachment=False)
crypted_content = fields.Char()
uuid = fields.Char(default=lambda self: uuid4())
path = fields.Many2one(
"vault.import.wizard.path",
"Path to import",
default="",
domain="[('uuid', '=', uuid)]",
)
@api.onchange("crypted_content", "content")
def _onchange_content(self):
for rec in self:
if rec.crypted_content:
for entry in json.loads(rec.crypted_content or []):
rec._create_path(entry)
def _create_path(self, entry, path=None):
self.ensure_one()
p = f"{path} / {entry['name']}" if path else entry["name"]
if "name" in entry:
self.env["vault.import.wizard.path"].create({"uuid": self.uuid, "name": p})
for child in entry.get("childs", []):
self._create_path(child, p)
def _import_field(self, entry, model, data):
if not data:
return
# Only copy specific fields
vals = {f: data[f] for f in ["name", "iv", "value"]}
# Update already existing records
domain = [("entry_id", "=", entry.id), ("name", "=", data["name"])]
rec = model.search(domain)
if rec:
rec.write(vals)
else:
rec.create({"entry_id": entry.id, **vals})
def _import_entry(self, entry, parent=None, path=None):
p = f"{path} / {entry['name']}" if path else entry["name"]
result = self.env["vault.entry"]
if p.startswith(self.path.name or ""):
if not parent:
parent = self.env["vault.entry"]
# Update existing records if already imported
rec = self.env["vault.entry"]
if entry.get("uuid"):
domain = [
("uuid", "=", entry["uuid"]),
("vault_id", "=", self.vault_id.id),
]
rec = rec.search(domain, limit=1)
# If record not found create a new one
vals = {f: entry.get(f) for f in ["name", "note", "url", "uuid"]}
if not rec:
rec = rec.create(
{"vault_id": self.vault_id.id, "parent_id": parent.id, **vals}
)
else:
rec.write({"parent_id": parent.id, **vals})
# Create/update the entry fields
for field in entry.get("fields", []):
self._import_field(rec, self.env["vault.field"], field)
# Create/update the entry files
for file in entry.get("files", []):
self._import_field(rec, self.env["vault.file"], file)
result |= rec
else:
rec = None
# Create the sub-entries
for child in entry.get("childs", []):
result |= self._import_entry(child, rec, p)
return result
def action_import(self):
self.ensure_one()
try:
data = json.loads(self.crypted_content)
entries = self.env["vault.entry"]
for entry in data:
entries |= self.with_context(skip_log=True)._import_entry(
entry, self.parent_id
)
self.vault_id.log_entry(f"Imported entries from file {self.name}")
except Exception as e:
raise UserError(_("Invalid file to import from")) from e
| 32.19403 | 4,314 |
4,640 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import _, http
from odoo.http import request
_logger = logging.getLogger(__name__)
class Controller(http.Controller):
@http.route("/vault/inbox/<string:token>", type="http", auth="public")
def vault_inbox(self, token):
ctx = {"disable_footer": True, "token": token}
# Find the right token
inbox = request.env["vault.inbox"].sudo().find_inbox(token)
user = request.env["res.users"].sudo().find_user_of_inbox(token)
if len(inbox) == 1 and inbox.accesses > 0:
ctx.update({"name": inbox.name, "public": inbox.user_id.active_key.public})
elif len(inbox) == 0 and len(user) == 1:
ctx["public"] = user.active_key.public
# A valid token would mean we found a public key
if not ctx.get("public"):
ctx["error"] = _("Invalid token")
return request.render("vault.inbox", ctx)
# Just render if GET method
if request.httprequest.method != "POST":
return request.render("vault.inbox", ctx)
# Check the param
name = request.params.get("name")
secret = request.params.get("encrypted")
secret_file = request.params.get("encrypted_file")
filename = request.params.get("filename")
iv = request.params.get("iv")
key = request.params.get("key")
if not name:
ctx["error"] = _("Please specify a name")
return request.render("vault.inbox", ctx)
if not secret and not secret_file:
ctx["error"] = _("No secret found")
return request.render("vault.inbox", ctx)
if secret_file and not filename:
ctx["error"] = _("Missing filename")
return request.render("vault.inbox", ctx)
if not iv or not key:
ctx["error"] = _("Something went wrong with the encryption")
return request.render("vault.inbox", ctx)
try:
inbox.store_in_inbox(
name,
secret,
secret_file,
iv,
key,
user,
filename,
ip=request.httprequest.remote_addr,
)
except Exception as e:
_logger.exception(e)
ctx["error"] = _(
"An error occured. Please contact the user or administrator"
)
return request.render("vault.inbox", ctx)
ctx["message"] = _("Successfully stored")
return request.render("vault.inbox", ctx)
@http.route("/vault/public", type="json")
def vault_public(self, user_id):
"""Get the public key of a specific user"""
user = request.env["res.users"].sudo().browse(user_id).exists()
if not user or not user.keys:
return {}
return {"public_key": user.active_key.public}
@http.route("/vault/inbox/get", auth="user", type="json")
def vault_get_inbox(self):
inboxes = request.env.user.inbox_ids
return {inbox.token: inbox.key for inbox in inboxes}
@http.route("/vault/inbox/store", auth="user", type="json")
def vault_store_inbox(self, keys):
if not isinstance(keys, dict):
return
for inbox in request.env.user.inbox_ids:
key = keys.get(inbox.token)
if isinstance(key, str):
inbox.key = key
@http.route("/vault/keys/store", auth="user", type="json")
def vault_store_keys(self, **kwargs):
"""Store the key pair for the current user"""
return request.env["res.users.key"].store(**kwargs)
@http.route("/vault/keys/get", auth="user", type="json")
def vault_get_keys(self):
"""Get the currently active key pair"""
return request.env.user.get_vault_keys()
@http.route("/vault/rights/get", auth="user", type="json")
def vault_get_right_keys(self):
"""Get the master keys from the vault.right records"""
rights = request.env.user.vault_right_ids
return {right.vault_id.uuid: right.key for right in rights}
@http.route("/vault/rights/store", auth="user", type="json")
def vault_store_right_keys(self, keys):
"""Store the master keys to the specific vault.right records"""
if not isinstance(keys, dict):
return
for right in request.env.user.vault_right_ids:
master_key = keys.get(right.vault_id.uuid)
if isinstance(master_key, str):
right.sudo().key = master_key
| 36.242188 | 4,639 |
893 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# Copyright 2020 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
import logging
from psycopg2 import sql
_logger = logging.getLogger(__name__)
def pre_init_hook(cr):
"""Initialize the value of the given column for existing rows in a fast way."""
_logger.info(
"Initializing column `unit_amount_rounded` with the " "value of `unit_amount`"
)
table = sql.Identifier("account_analytic_line")
column = sql.Identifier("unit_amount_rounded")
cr.execute( # pylint: disable=E8103
sql.SQL("ALTER TABLE {} ADD COLUMN IF NOT EXISTS {} NUMERIC").format(
table, column
)
)
cr.execute( # pylint: disable=E8103
sql.SQL(
"UPDATE {table} SET {column} = unit_amount WHERE {column} IS NULL"
).format(table=table, column=column),
)
| 31.892857 | 893 |
725 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# Copyright 2020 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
{
"name": "Sale Timesheet Rounded",
"summary": "Round timesheet entries amount based on project settings.",
"version": "15.0.1.0.0",
"author": "Camptocamp, Odoo Community Association (OCA)",
"license": "AGPL-3",
"category": "Sales",
"website": "https://github.com/OCA/timesheet",
"depends": ["project", "hr_timesheet", "sale_timesheet"],
"data": [
# Views
"views/account_analytic_line.xml",
"views/project_project.xml",
"views/project_task.xml",
],
"installable": True,
"pre_init_hook": "pre_init_hook",
}
| 34.52381 | 725 |
10,607 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
import odoo
from odoo import fields
from odoo.addons.sale_timesheet.tests.common import TestCommonSaleTimesheet
@odoo.tests.tagged("post_install", "-at_install")
class TestRounded(TestCommonSaleTimesheet):
@classmethod
def setUpClass(cls, chart_template_ref=None):
super().setUpClass(chart_template_ref=chart_template_ref)
cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
cls.sale_order = cls.env["sale.order"].create(
{
"analytic_account_id": cls.project_global.analytic_account_id.id,
"partner_id": cls.partner_a.id,
"partner_invoice_id": cls.partner_a.id,
"partner_shipping_id": cls.partner_a.id,
}
)
sale_order_line = cls.env["sale.order.line"].create(
{
"order_id": cls.sale_order.id,
"name": cls.product_delivery_timesheet2.name,
"product_id": cls.product_delivery_timesheet2.id,
"product_uom_qty": 1,
"product_uom": cls.product_delivery_timesheet2.uom_id.id,
"price_unit": cls.product_delivery_timesheet2.list_price,
}
)
sale_order_line.product_id_change()
cls.sale_order.action_confirm()
cls.project_global.write(
{
"timesheet_rounding_unit": 0.25,
"timesheet_rounding_method": "UP",
"timesheet_rounding_factor": 200,
}
)
cls.product_expense = cls.env["product.product"].create(
{
"name": "Service delivered, EXPENSE",
"expense_policy": "cost",
"standard_price": 30,
"list_price": 90,
"type": "service",
"invoice_policy": "order",
"uom_id": cls.product_delivery_timesheet2.uom_id.id,
"uom_po_id": cls.product_delivery_timesheet2.uom_id.id,
}
)
cls.avg_analytic_account = cls.env["account.analytic.account"].create(
{"name": "AVG account"}
)
def create_analytic_line(self, **kw):
task = self.sale_order.tasks_ids[0]
values = {
"project_id": self.project_global.id,
"task_id": task.id,
"name": "Rounded test line",
"date": fields.Date.today(),
"unit_amount": 0,
"product_id": self.product_delivery_timesheet2.id,
"employee_id": self.employee_user.id,
}
values.update(kw)
return self.env["account.analytic.line"].create(values)
def test_analytic_line_init_no_rounding(self):
lines = self.env["account.analytic.line"].search([])
for line in lines:
self.assertEqual(line.unit_amount_rounded, line.unit_amount)
def test_analytic_line_create_no_rounding(self):
self.project_global.write({"timesheet_rounding_method": "NO"})
# no rounding enabled
line = self.create_analytic_line(unit_amount=1)
self.assertEqual(line.unit_amount, 1.0)
self.assertEqual(line.unit_amount_rounded, line.unit_amount)
def test_analytic_line_create(self):
line = self.create_analytic_line(unit_amount=1)
self.assertEqual(line.unit_amount_rounded, 2.0)
line = self.create_analytic_line(unit_amount=1, unit_amount_rounded=0)
self.assertEqual(line.unit_amount_rounded, 0.0)
def test_analytic_line_create_and_update_amount_rounded(self):
line = self.create_analytic_line(unit_amount=2)
self.assertEqual(line.unit_amount_rounded, 4.0)
line.write({"unit_amount_rounded": 5.0})
self.assertEqual(line.unit_amount_rounded, 5.0)
line.write({"unit_amount_rounded": 0.0})
self.assertEqual(line.unit_amount_rounded, 0.0)
def test_analytic_line_create_and_update_amount(self):
line = self.create_analytic_line(unit_amount=2)
self.assertEqual(line.unit_amount_rounded, 4.0)
line.unit_amount = 5.0
self.assertEqual(line.unit_amount_rounded, 10.0)
def test_analytic_line_read_group_override(self):
# Test of the read group with an without timesheet_rounding context
# without context the unit_amount should be the initial
# with the context the value of unit_amount should be replaced by the
# unit_amount_rounded
line = self.env["account.analytic.line"]
self.create_analytic_line(unit_amount=1)
domain = [("project_id", "=", self.project_global.id)]
fields_list = ["so_line", "unit_amount", "product_uom_id"]
groupby = ["product_uom_id", "so_line"]
data_ctx_f = line.read_group(
domain,
fields_list,
groupby,
)
self.assertEqual(data_ctx_f[0]["unit_amount"], 1.0)
data_ctx_t = line.with_context(timesheet_rounding=True).read_group(
domain,
fields_list,
groupby,
)
self.assertEqual(data_ctx_t[0]["unit_amount"], 2.0)
self.create_analytic_line(unit_amount=1.1)
data_ctx_f = line.with_context(timesheet_rounding=False).read_group(
domain,
fields_list,
groupby,
)
self.assertEqual(data_ctx_f[0]["unit_amount"], 2.1)
data_ctx_f = line.with_context(timesheet_rounding=True).read_group(
domain,
fields_list,
groupby,
)
self.assertEqual(data_ctx_f[0]["unit_amount"], 4.25)
def test_analytic_line_read_override(self):
# Cases for not rounding:
# * not linked to project -> no impact
# * is an expense -> no impact
# * ctx key for rounding is set to false -> no impact
# In all the other cases we check that unit amount is rounded.
load = "_classic_read"
fields = None
# context = False + project_id - product_expense
line = self.create_analytic_line(unit_amount=1)
unit_amount_ret = line.read(fields, load)[0]["unit_amount"]
self.assertEqual(unit_amount_ret, 1)
# context = True - project - product_expense
line = self.create_analytic_line(
unit_amount=1, project_id=False, account_id=self.avg_analytic_account.id
)
unit_amount_ret = line.with_context(timesheet_rounding=True).read(fields, load)[
0
]["unit_amount"]
self.assertEqual(unit_amount_ret, 1)
# context = True + project_id + product_expense
line = self.create_analytic_line(
unit_amount=1, product_id=self.product_expense.id
)
unit_amount_ret = line.with_context(timesheet_rounding=True).read(fields, load)[
0
]["unit_amount"]
self.assertEqual(unit_amount_ret, 2)
# context = True + project_id - product_expense
line = self.create_analytic_line(unit_amount=1)
unit_amount_ret = line.with_context(timesheet_rounding=True).read(fields, load)[
0
]["unit_amount"]
self.assertEqual(unit_amount_ret, 2)
def test_sale_order_qty_1(self):
# amount=1 -> should be rounded to 2 by the invoicing_factor
self.create_analytic_line(unit_amount=1)
self.assertAlmostEqual(self.sale_order.order_line.qty_delivered, 2.0)
self.assertAlmostEqual(self.sale_order.order_line.qty_to_invoice, 2.0)
self.assertAlmostEqual(self.sale_order.order_line.qty_invoiced, 0)
def test_sale_order_qty_2(self):
# force amount_rounded=4
self.create_analytic_line(unit_amount=1, unit_amount_rounded=4)
self.assertAlmostEqual(self.sale_order.order_line.qty_delivered, 4.0)
self.assertAlmostEqual(self.sale_order.order_line.qty_to_invoice, 4.0)
self.assertAlmostEqual(self.sale_order.order_line.qty_invoiced, 0)
def test_sale_order_qty_3(self):
# amount=0.9
# should be rounded to 2 by the invoicing_factor with the project
# timesheet_rounding_unit: 0.25
# timesheet_rounding_method: 'UP'
# timesheet_rounding_factor: 200
self.create_analytic_line(unit_amount=0.9)
self.assertAlmostEqual(self.sale_order.order_line.qty_delivered, 2.0)
self.assertAlmostEqual(self.sale_order.order_line.qty_to_invoice, 2.0)
self.assertAlmostEqual(self.sale_order.order_line.qty_invoiced, 0)
def test_sale_order_qty_4(self):
# amount=0.9
# should be rounded to 2 by the invoicing_factor with the project
# timesheet_rounding_unit: 0.25
# timesheet_rounding_method: 'UP'
# timesheet_rounding_factor: 200
self.project_global.timesheet_rounding_factor = 400
self.create_analytic_line(unit_amount=1.0)
self.assertAlmostEqual(self.sale_order.order_line.qty_delivered, 4.0)
self.assertAlmostEqual(self.sale_order.order_line.qty_to_invoice, 4.0)
self.assertAlmostEqual(self.sale_order.order_line.qty_invoiced, 0)
def test_calc_rounded_amount_method(self):
aal = self.env["account.analytic.line"]
rounding_unit = 0.25
rounding_method = "UP"
factor = 200
amount = 1
self.assertEqual(
aal._calc_rounded_amount(rounding_unit, rounding_method, factor, amount), 2
)
rounding_unit = 0.0
rounding_method = "UP"
factor = 200
amount = 1
self.assertEqual(
aal._calc_rounded_amount(rounding_unit, rounding_method, factor, amount), 2
)
rounding_unit = 0.25
rounding_method = "UP"
factor = 100
amount = 1.0
self.assertEqual(
aal._calc_rounded_amount(rounding_unit, rounding_method, factor, amount), 1
)
rounding_unit = 0.25
rounding_method = "UP"
factor = 200
amount = 0.9
self.assertEqual(
aal._calc_rounded_amount(rounding_unit, rounding_method, factor, amount), 2
)
rounding_unit = 1.0
rounding_method = "UP"
factor = 200
amount = 0.6
self.assertEqual(
aal._calc_rounded_amount(rounding_unit, rounding_method, factor, amount), 2
)
rounding_unit = 0.25
rounding_method = "HALF_UP"
factor = 200
amount = 1.01
self.assertEqual(
aal._calc_rounded_amount(rounding_unit, rounding_method, factor, amount), 2
)
| 39.578358 | 10,607 |
1,332 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
from odoo import fields, models
class ProjectProject(models.Model):
_inherit = "project.project"
timesheet_rounding_unit = fields.Float(
string="Rounding Unit",
default=0.0,
help="""1.0 = hour
0.25 = 15 min
0.084 ~= 5 min
0.017 ~= 1 min
""",
)
timesheet_rounding_method = fields.Selection(
string="Rounding method",
selection=[
("NO", "No rounding"),
("UP", "Up"),
("HALF_UP", "Closest"),
("DOWN", "Down"),
],
default="NO",
required=True,
help="If you activate the rounding of timesheet lines, only new "
"entries will be rounded (i.e. existing lines will not be "
"rounded automatically).",
)
timesheet_rounding_factor = fields.Float(
string="Timesheet rounding factor in percentage", default=100.0
)
_sql_constraints = [
(
"check_timesheet_rounding_factor",
"CHECK(0 <= timesheet_rounding_factor "
"AND timesheet_rounding_factor <= 500)",
"Timesheet rounding factor should stay between 0 and 500,"
" endpoints included.",
)
]
| 29.6 | 1,332 |
4,065 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# Copyright 2020 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
from odoo import api, fields, models
from odoo.tools.float_utils import float_round
class AccountAnalyticLine(models.Model):
_inherit = "account.analytic.line"
unit_amount_rounded = fields.Float(
string="Quantity rounded",
compute="_compute_unit_rounded",
store=True,
readonly=False,
copy=False,
)
@api.depends("project_id", "unit_amount")
def _compute_unit_rounded(self):
for record in self:
record.unit_amount_rounded = record._calc_unit_amount_rounded()
def _calc_unit_amount_rounded(self):
self.ensure_one()
project_rounding = (
self.project_id and self.project_id.timesheet_rounding_method != "NO"
)
if project_rounding:
return self._calc_rounded_amount(
self.project_id.timesheet_rounding_unit,
self.project_id.timesheet_rounding_method,
self.project_id.timesheet_rounding_factor,
self.unit_amount,
)
else:
return self.unit_amount
@staticmethod
def _calc_rounded_amount(rounding_unit, rounding_method, factor, amount):
factor = factor / 100.0
if rounding_unit:
unit_amount_rounded = float_round(
amount * factor,
precision_rounding=rounding_unit,
rounding_method=rounding_method,
)
else:
unit_amount_rounded = amount * factor
return unit_amount_rounded
####################################################
# ORM Overrides
####################################################
@api.model
def read_group(
self, domain, fields, groupby, offset=0, limit=None, orderby=False, lazy=True
):
"""Replace the value of unit_amount by unit_amount_rounded.
When context key `timesheet_rounding` is True
we change the value of unit_amount with the rounded one.
This affects `sale_order_line._compute_delivered_quantity`
which in turns compute the delivered qty on SO line.
"""
ctx_ts_rounded = self.env.context.get("timesheet_rounding")
fields_local = list(fields) if fields else []
if ctx_ts_rounded and "unit_amount_rounded" not in fields_local:
# To add the unit_amount_rounded value on read_group
fields_local.append("unit_amount_rounded")
res = super().read_group(
domain,
fields_local,
groupby,
offset=offset,
limit=limit,
orderby=orderby,
lazy=lazy,
)
if ctx_ts_rounded:
# To set the unit_amount_rounded value instead of unit_amount
for rec in res:
rec["unit_amount"] = rec["unit_amount_rounded"]
return res
def read(self, fields=None, load="_classic_read"):
"""Replace the value of unit_amount by unit_amount_rounded.
When context key `timesheet_rounding` is True
we change the value of unit_amount with the rounded one.
This affects `account_analytic_line._sale_determine_order_line`.
"""
ctx_ts_rounded = self.env.context.get("timesheet_rounding")
fields_local = list(fields) if fields else []
read_unit_amount = "unit_amount" in fields_local or not fields_local
if ctx_ts_rounded and read_unit_amount and fields_local:
if "unit_amount_rounded" not in fields_local:
# To add the unit_amount_rounded value on read
fields_local.append("unit_amount_rounded")
res = super().read(fields=fields_local, load=load)
if ctx_ts_rounded and read_unit_amount:
# To set the unit_amount_rounded value instead of unit_amount
for rec in res:
rec["unit_amount"] = rec["unit_amount_rounded"]
return res
| 37.638889 | 4,065 |
958 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
from odoo import api, models
class SaleOrderLine(models.Model):
_inherit = "sale.order.line"
def _get_delivered_quantity_by_analytic(self, additional_domain):
# If we land here is only because we are dealing w/ SO lines
# having `qty_delivered_method` equal to `analytic` or `timesheet`.
# The 1st case matches expenses lines the latter TS lines.
# Expenses are already discarded in our a.a.l. overrides
# so it's fine to set the ctx key here anyway.
return super(
SaleOrderLine, self.with_context(timesheet_rounding=True)
)._get_delivered_quantity_by_analytic(additional_domain)
@api.depends("analytic_line_ids.unit_amount_rounded")
def _compute_qty_delivered(self):
"""Adds the dependency on unit_amount_rounded."""
return super()._compute_qty_delivered()
| 41.652174 | 958 |
635 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2020 Open Source Integrators
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Time Type in Timesheet",
"summary": "Ability to add time type in timesheet lines.",
"version": "15.0.1.0.0",
"license": "AGPL-3",
"author": "Open Source Integrators, Odoo Community Association (OCA)",
"category": "Timesheet",
"website": "https://github.com/OCA/timesheet",
"depends": ["hr_timesheet"],
"data": [
"security/ir.model.access.csv",
"views/project_time_type_view.xml",
"views/account_analytic_line_view.xml",
],
"installable": True,
}
| 33.421053 | 635 |
348 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2020 Open Source Integrators
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ProjectTimeType(models.Model):
_name = "project.time.type"
_description = "Define Time Types"
name = fields.Char(required=True)
code = fields.Char()
description = fields.Text()
| 26.769231 | 348 |
447 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2020 Open Source Integrators
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class AccountAnalyticLine(models.Model):
_inherit = "account.analytic.line"
time_type_id = fields.Many2one(
comodel_name="project.time.type",
string="Time Type",
)
time_type_name = fields.Char(
related="time_type_id.name",
string="Time Type Name",
)
| 26.294118 | 447 |
750 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Antiun - Antonio Espinosa
# Copyright 2015 Antiun - Javier Iniesta
# Copyright 2017 Tecnativa - David Vidal
# Copyright 2019 Tecnativa - Jairo Llopis
# Copyright 2020 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "CRM Timesheet",
"category": "Customer Relationship Management",
"version": "15.0.1.0.0",
"depends": ["crm", "project_timesheet_time_control"],
"data": [
"security/ir.model.access.csv",
"views/crm_lead_view.xml",
"views/hr_timesheet_view.xml",
],
"author": "Tecnativa, Odoo Community Association (OCA)",
"website": "https://github.com/OCA/timesheet",
"license": "AGPL-3",
"installable": True,
}
| 34.090909 | 750 |
2,726 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Jairo Llopis <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.tests.common import TransactionCase
class AccountAnalyticLineCase(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
admin = cls.env.ref("base.user_admin")
# Stop any timer running
cls.env["account.analytic.line"].search(
[
("date_time", "!=", False),
("user_id", "=", admin.id),
("project_id.allow_timesheets", "=", True),
("unit_amount", "=", 0),
]
).button_end_work()
admin.groups_id |= cls.env.ref(
"hr_timesheet.group_hr_timesheet_user"
) | cls.env.ref("sales_team.group_sale_salesman")
env = cls.env(user=admin)
Account = env["account.analytic.account"]
Project = env["project.project"]
cls.account1 = Account.create(
{
"name": "Test Account 1",
}
)
cls.project1 = Project.create(
{
"name": "Test Project 1",
"analytic_account_id": cls.account1.id,
}
)
cls.lead = env["crm.lead"].create(
{
"name": "Test lead",
"project_id": cls.project1.id,
}
)
def setUp(self):
super().setUp()
self.uid = self.ref("base.user_admin")
def _create_wizard(self, action, active_record):
"""Create a new hr.timesheet.switch wizard in the specified context.
:param dict action: Action definition that creates the wizard.
:param active_record: Record being browsed when creating the wizard.
"""
self.assertEqual(action["res_model"], "hr.timesheet.switch")
self.assertEqual(action["target"], "new")
self.assertEqual(action["type"], "ir.actions.act_window")
self.assertEqual(action["view_mode"], "form")
self.assertEqual(action["view_type"], "form")
return (
active_record.env[action["res_model"]]
.with_context(
active_id=active_record.id,
active_ids=active_record.ids,
active_model=active_record._name,
**action.get("context", {}),
)
.create({})
)
def test_onchange_lead(self):
"""Changing the lead changes the associated project."""
line = self.env["account.analytic.line"].new(
{
"lead_id": self.lead.id,
}
)
line._onchange_lead_id()
self.assertEqual(line.project_id, self.project1)
| 34.506329 | 2,726 |
1,069 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Antonio Espinosa <[email protected]>
# Copyright 2015 Javier Iniesta <[email protected]>
# Copyright 2017 David Vidal <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models
class CrmLead(models.Model):
_name = "crm.lead"
_inherit = ["crm.lead", "hr.timesheet.time_control.mixin"]
project_id = fields.Many2one(comodel_name="project.project", string="Project")
timesheet_ids = fields.One2many(
comodel_name="account.analytic.line",
inverse_name="lead_id",
string="Timesheet",
)
@api.model
def _relation_with_timesheet_line(self):
return "lead_id"
@api.depends("timesheet_ids.employee_id", "timesheet_ids.unit_amount")
def _compute_show_time_control(self):
return super()._compute_show_time_control()
def button_start_work(self):
result = super().button_start_work()
result["context"].update({"default_project_id": self.project_id.id})
return result
| 34.483871 | 1,069 |
629 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Antonio Espinosa <[email protected]>
# Copyright 2015 Javier Iniesta <[email protected]>
# Copyright 2017 David Vidal <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models
class AccountAnalyticLine(models.Model):
_inherit = "account.analytic.line"
lead_id = fields.Many2one(
comodel_name="crm.lead",
string="Lead/Opportunity",
)
@api.onchange("lead_id")
def _onchange_lead_id(self):
if self.lead_id.project_id:
self.project_id = self.lead_id.project_id.id
| 31.45 | 629 |
783 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Tecnativa - Jairo Llopis
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, models
class HrTimesheetSwitch(models.TransientModel):
_inherit = "hr.timesheet.switch"
@api.model
def _closest_suggestion(self):
"""Allow searching best suggestion by lead."""
context = self.env.context
if context.get("active_model") == "crm.lead":
return self.env["account.analytic.line"].search(
[
("employee_id", "in", self.env.user.employee_ids.ids),
("lead_id", "=", context.get("active_id", 0)),
],
order="date_time DESC",
limit=1,
)
return super()._closest_suggestion()
| 34.043478 | 783 |
836 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Tecnativa - Antonio Espinosa
# Copyright 2016 Tecnativa - Sergio Teruel
# Copyright 2016-2018 Tecnativa - Pedro M. Baeza
# Copyright 2018 Tecnativa - Ernesto Tejeda
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Task Log: Open/Close Task",
"version": "15.0.1.0.1",
"category": "Operations/Timesheets",
"website": "https://github.com/OCA/timesheet",
"author": "Tecnativa, CorporateHub, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"application": False,
"summary": "Open/Close task from corresponding Task Log entry",
"depends": ["hr_timesheet"],
"data": ["views/account_analytic_line.xml"],
}
| 39.809524 | 836 |
1,955 |
py
|
PYTHON
|
15.0
|
# Copyright 2016-2018 Tecnativa - Pedro M. Baeza
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 Tecnativa - Manuel Calero
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests import common
class TestHrTimesheetTaskStage(common.TransactionCase):
def setUp(self):
super().setUp()
self.project = self.env["project.project"].create({"name": "Test project"})
self.analytic_account = self.project.analytic_account_id
self.task = self.env["project.task"].create(
{"name": "Test task", "project_id": self.project.id}
)
task_type_obj = self.env["project.task.type"]
self.stage_open = task_type_obj.create(
{
"name": "New",
"is_closed": False,
"project_ids": [(6, 0, self.project.ids)],
}
)
self.stage_close = task_type_obj.create(
{
"name": "Done",
"is_closed": True,
"project_ids": [(6, 0, self.project.ids)],
}
)
self.line = self.env["account.analytic.line"].create(
{
"task_id": self.task.id,
"account_id": self.analytic_account.id,
"name": "Test line",
}
)
def test_open_close_task(self):
self.line.action_close_task()
self.assertEqual(self.line.task_id.stage_id, self.stage_close)
self.line.action_open_task()
self.assertEqual(self.line.task_id.stage_id, self.stage_open)
def test_toggle_task_stage(self):
self.line.action_toggle_task_stage()
self.assertTrue(self.line.task_id.stage_id.is_closed)
self.assertTrue(self.line.is_task_closed)
self.line.action_toggle_task_stage()
self.assertFalse(self.line.task_id.stage_id.is_closed)
self.assertFalse(self.line.is_task_closed)
| 36.886792 | 1,955 |
2,167 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Tecnativa - Antonio Espinosa
# Copyright 2016 Tecnativa - Sergio Teruel
# Copyright 2016-2018 Tecnativa - Pedro M. Baeza
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 Tecnativa - Manuel Calero
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import _, fields, models
from odoo.exceptions import UserError
class AccountAnalyticLine(models.Model):
_inherit = "account.analytic.line"
is_task_closed = fields.Boolean(related="task_id.stage_id.is_closed")
def action_open_task(self):
ProjectTaskType = self.env["project.task.type"]
for line in self.filtered("task_id.project_id"):
stage = ProjectTaskType.search(
[
("project_ids", "=", line.task_id.project_id.id),
("is_closed", "=", False),
],
limit=1,
)
if not stage: # pragma: no cover
raise UserError(
_(
'There isn\'t any stage with "Closed" unchecked.'
" Please unmark any."
)
)
line.task_id.write({"stage_id": stage.id})
def action_close_task(self):
ProjectTaskType = self.env["project.task.type"]
for line in self.filtered("task_id.project_id"):
stage = ProjectTaskType.search(
[
("project_ids", "=", line.task_id.project_id.id),
("is_closed", "=", True),
],
limit=1,
)
if not stage: # pragma: no cover
raise UserError(
_(
'There isn\'t any stage with "Closed" checked. Please'
" mark any."
)
)
line.task_id.write({"stage_id": stage.id})
def action_toggle_task_stage(self):
for line in self.filtered("task_id.project_id"):
if line.is_task_closed:
line.action_open_task()
else:
line.action_close_task()
| 34.951613 | 2,167 |
842 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Tecnativa - Antonio Espinosa
# Copyright 2016 Tecnativa - Sergio Teruel
# Copyright 2016-2018 Tecnativa - Pedro M. Baeza
# Copyright 2018 Tecnativa - Ernesto Tejeda
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 Tecnativa - Manuel Calero
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Task Log: limit Task by Project",
"version": "15.0.1.0.0",
"category": "Human Resources",
"website": "https://github.com/OCA/timesheet",
"author": "Tecnativa, CorporateHub, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"application": False,
"summary": ("Limit task selection to tasks on currently-selected project"),
"depends": ["hr_timesheet"],
}
| 40.095238 | 842 |
1,297 |
py
|
PYTHON
|
15.0
|
# Copyright 2016-2018 Tecnativa - Pedro M. Baeza
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests import common
class TestHrTimesheetTaskDomain(common.TransactionCase):
def setUp(self):
super().setUp()
self.project = self.env["project.project"].create({"name": "Test project"})
self.analytic_account = self.project.analytic_account_id
self.task = self.env["project.task"].create(
{"name": "Test task", "project_id": self.project.id}
)
self.line = self.env["account.analytic.line"].create(
{
"task_id": self.task.id,
"account_id": self.analytic_account.id,
"name": "Test line",
}
)
def test_onchange_project_id(self):
record = self.env["account.analytic.line"].new()
record.task_id = self.task.id
record.project_id = self.project.id
action = record._onchange_project_id()
self.assertTrue(action["domain"]["task_id"])
self.assertEqual(record.task_id, self.task)
record.project_id = False
action = record._onchange_project_id()
self.assertEqual(action["domain"]["task_id"], [])
| 38.147059 | 1,297 |
1,150 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Tecnativa - Antonio Espinosa
# Copyright 2016 Tecnativa - Sergio Teruel
# Copyright 2016-2018 Tecnativa - Pedro M. Baeza
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, models
class AccountAnalyticLine(models.Model):
_inherit = "account.analytic.line"
@api.onchange("project_id")
def _onchange_project_id(self):
task = self.task_id
res = super()._onchange_project_id()
if res is None:
res = {}
if self.project_id: # Show only opened tasks
task_domain = [
("project_id", "=", self.project_id.id),
("stage_id.is_closed", "=", False),
]
res_domain = res.setdefault("domain", {})
res_domain.update({"task_id": task_domain})
else: # Reset domain for allowing selection of any task
res["domain"] = {"task_id": []}
if task.project_id == self.project_id:
# Restore previous task if belongs to the same project
self.task_id = task
return res
| 37.096774 | 1,150 |
561 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Camptocamp SA - Guewen Baconnier
# Copyright 2017 Tecnativa, S.L. - Luis M. Ontalba
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
{
"name": "Timesheet - Begin/End Hours",
"version": "15.0.1.0.0",
"author": "Camptocamp, Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"category": "Human Resources",
"depends": ["hr_timesheet"],
"website": "https://github.com/OCA/timesheet",
"data": ["views/hr_analytic_timesheet.xml"],
"installable": True,
"auto_install": False,
}
| 35.0625 | 561 |
3,265 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Camptocamp SA - Guewen Baconnier
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
from odoo import exceptions, fields
from odoo.tests import common
class TestBeginEnd(common.TransactionCase):
def setUp(self):
super(TestBeginEnd, self).setUp()
self.timesheet_line_model = self.env["account.analytic.line"]
self.analytic = self.env.ref("analytic.analytic_administratif")
self.user = self.env.ref("base.user_root")
self.base_line = {
"name": "test",
"date": fields.Date.today(),
"time_start": 10.0,
"time_stop": 12.0,
"user_id": self.user.id,
"unit_amount": 2.0,
"account_id": self.analytic.id,
"amount": -60.0,
}
def test_onchange(self):
line = self.timesheet_line_model.new(
{"name": "test", "time_start": 10.0, "time_stop": 12.0}
)
line.onchange_hours_start_stop()
self.assertEqual(line.unit_amount, 2)
def test_onchange_no_update(self):
line = self.timesheet_line_model.new(
{"name": "test", "time_start": 13.0, "time_stop": 12.0}
)
line.onchange_hours_start_stop()
self.assertEqual(line.unit_amount, 0)
def test_check_begin_before_end(self):
line = self.base_line.copy()
line.update({"time_start": 12.0, "time_stop": 10.0})
with self.assertRaises(exceptions.ValidationError):
self.timesheet_line_model.create(line)
def test_check_wrong_duration(self):
message_re = (
r"The duration \(\d\d:\d\d\) must be equal to the "
r"difference between the hours \(\d\d:\d\d\)\."
)
line = self.base_line.copy()
line.update({"time_start": 10.0, "time_stop": 12.0, "unit_amount": 5.0})
with self.assertRaisesRegex(exceptions.ValidationError, message_re):
self.timesheet_line_model.create(line)
def test_check_overlap(self):
line1 = self.base_line.copy()
line1.update({"time_start": 10.0, "time_stop": 12.0, "unit_amount": 2.0})
line2 = self.base_line.copy()
line2.update({"time_start": 12.0, "time_stop": 14.0, "unit_amount": 2.0})
self.timesheet_line_model.create(line1)
self.timesheet_line_model.create(line2)
message_re = r"overlap"
line3 = self.base_line.copy()
line3.update({"time_start": 9.0, "time_stop": 11, "unit_amount": 2.0})
with self.assertRaisesRegex(exceptions.ValidationError, message_re):
self.timesheet_line_model.create(line3)
line3.update({"time_start": 13.0, "time_stop": 15, "unit_amount": 2.0})
with self.assertRaisesRegex(exceptions.ValidationError, message_re):
self.timesheet_line_model.create(line3)
line3.update({"time_start": 8.0, "time_stop": 15, "unit_amount": 7.0})
with self.assertRaisesRegex(exceptions.ValidationError, message_re):
self.timesheet_line_model.create(line3)
def test_check_precision(self):
line1 = self.base_line.copy()
line1.update({"time_start": 19.0, "time_stop": 20.314, "unit_amount": 1.314})
self.timesheet_line_model.create(line1)
| 39.817073 | 3,265 |
3,653 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Camptocamp SA - Guewen Baconnier
# Copyright 2017 Tecnativa, S.L. - Luis M. Ontalba
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
from datetime import timedelta
from odoo import _, api, exceptions, fields, models
from odoo.tools.float_utils import float_compare
class AccountAnalyticLine(models.Model):
_inherit = "account.analytic.line"
_order = "date desc, time_start desc, id desc"
time_start = fields.Float(string="Begin Hour")
time_stop = fields.Float(string="End Hour")
@api.constrains("time_start", "time_stop", "unit_amount")
def _check_time_start_stop(self):
for line in self:
value_to_html = self.env["ir.qweb.field.float_time"].value_to_html
start = timedelta(hours=line.time_start)
stop = timedelta(hours=line.time_stop)
if stop < start:
value_to_html(line.time_start, None)
value_to_html(line.time_stop, None)
raise exceptions.ValidationError(
_(
"The beginning hour (%(html_start)s) must "
"precede the ending hour (%(html_stop)s)."
)
% {
"html_start": value_to_html(line.time_start, None),
"html_stop": value_to_html(line.time_stop, None),
}
)
hours = (stop - start).seconds / 3600
rounding = self.env.ref("uom.product_uom_hour").rounding
if hours and float_compare(
hours, line.unit_amount, precision_rounding=rounding
):
raise exceptions.ValidationError(
_(
"The duration (%(html_unit_amount)s) must be equal to the difference "
"between the hours (%(html_hours)s)."
)
% {
"html_unit_amount": value_to_html(line.unit_amount, None),
"html_hours": value_to_html(hours, None),
}
)
# check if lines overlap
others = self.search(
[
("id", "!=", line.id),
("user_id", "=", line.user_id.id),
("date", "=", line.date),
("time_start", "<", line.time_stop),
("time_stop", ">", line.time_start),
]
)
if others:
message = _("Lines can't overlap:\n")
message += "\n".join(
[
"%s - %s"
% (
value_to_html(other.time_start, None),
value_to_html(other.time_stop, None),
)
for other in (line + others).sorted(lambda l: l.time_start)
]
)
raise exceptions.ValidationError(message)
@api.onchange("time_start", "time_stop")
def onchange_hours_start_stop(self):
start = timedelta(hours=self.time_start)
stop = timedelta(hours=self.time_stop)
if stop < start:
return
self.unit_amount = (stop - start).seconds / 3600
def merge_timesheets(self): # pragma: no cover
"""This method is needed in case hr_timesheet_sheet is installed"""
lines = self.filtered(lambda l: not l.time_start and not l.time_stop)
if lines:
return super(AccountAnalyticLine, lines).merge_timesheets()
return self[0]
| 40.588889 | 3,653 |
596 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Camptocamp SA - Guewen Baconnier
# Copyright 2017 Tecnativa, S.L. - Luis M. Ontalba
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
{
"name": "Timesheet Sheet - Begin/End Hours",
"version": "15.0.1.0.0",
"author": "Camptocamp, Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"category": "Human Resources",
"depends": ["hr_timesheet_begin_end", "hr_timesheet_sheet"],
"website": "https://github.com/OCA/timesheet",
"data": ["views/hr_timesheet_sheet.xml"],
"installable": True,
"auto_install": False,
}
| 37.25 | 596 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
1,153 |
py
|
PYTHON
|
15.0
|
import setuptools
with open('VERSION.txt', 'r') as f:
version = f.read().strip()
setuptools.setup(
name="odoo-addons-oca-timesheet",
description="Meta package for oca-timesheet Odoo addons",
version=version,
install_requires=[
'odoo-addon-crm_timesheet>=15.0dev,<15.1dev',
'odoo-addon-hr_employee_product>=15.0dev,<15.1dev',
'odoo-addon-hr_timesheet_begin_end>=15.0dev,<15.1dev',
'odoo-addon-hr_timesheet_sheet>=15.0dev,<15.1dev',
'odoo-addon-hr_timesheet_sheet_begin_end>=15.0dev,<15.1dev',
'odoo-addon-hr_timesheet_task_domain>=15.0dev,<15.1dev',
'odoo-addon-hr_timesheet_task_required>=15.0dev,<15.1dev',
'odoo-addon-hr_timesheet_task_stage>=15.0dev,<15.1dev',
'odoo-addon-hr_timesheet_time_type>=15.0dev,<15.1dev',
'odoo-addon-sale_timesheet_line_exclude>=15.0dev,<15.1dev',
'odoo-addon-sale_timesheet_rounded>=15.0dev,<15.1dev',
'odoo-addon-sale_timesheet_task_exclude>=15.0dev,<15.1dev',
],
classifiers=[
'Programming Language :: Python',
'Framework :: Odoo',
'Framework :: Odoo :: 15.0',
]
)
| 39.758621 | 1,153 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
106 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
106 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
572 |
py
|
PYTHON
|
15.0
|
# Copyright 2015-17 Eficent Business and IT Consulting Services S.L.
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl-3.0).
{
"name": "Manage products representing employees",
"version": "15.0.1.0.0",
"category": "Human Resources",
"author": "Eficent, Odoo Community Association (OCA)",
"website": "https://github.com/OCA/timesheet",
"license": "AGPL-3",
"summary": "Product is an employee",
"depends": ["product", "hr_timesheet"],
"data": ["security/product_security.xml", "view/product.xml"],
"installable": True,
}
| 38.133333 | 572 |
2,112 |
py
|
PYTHON
|
15.0
|
# Copyright 2015-17 Eficent Business and IT Consulting Services S.L.
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl-3.0).
from odoo.tests import common
class TestHrEmployeeProduct(common.TransactionCase):
def setUp(self):
super(TestHrEmployeeProduct, self).setUp()
self.res_users_model = self.env["res.users"].with_context(
tracking_disable=True, no_reset_password=True
)
self.grp_user = self.env.ref("base.group_user")
self.grp_hr_manager = self.env.ref("hr.group_hr_manager")
self.company = self.env.ref("base.main_company")
self.user1 = self._create_user("user1", [self.grp_user], self.company)
self.user2 = self._create_user("user2", [self.grp_hr_manager], self.company)
self.Product = self.env["product.product"]
self.product_1 = self.Product.create(
{
"name": "Marc",
"type": "service",
"default_code": "M-1",
"list_price": 40.0,
"standard_price": 20.0,
"is_employee": True,
}
)
def _create_user(self, login, groups, company, context=None):
"""Create a user."""
group_ids = [group.id for group in groups]
user = self.res_users_model.create(
{
"name": "Test User",
"login": login,
"password": "demo",
"email": "[email protected]",
"company_id": company.id,
"company_ids": [(4, company.id)],
"groups_id": [(6, 0, group_ids)],
}
)
return user
def test_01_hr_employee_product(self):
product_list1 = (
self.Product.sudo().with_user(self.user1).search([]).mapped("name")
)
product_list2 = (
self.Product.sudo().with_user(self.user2).search([]).mapped("name")
)
self.assertLess(
len(product_list1),
len(product_list2),
"User1 should" "have less products in the list",
)
| 34.622951 | 2,112 |
301 |
py
|
PYTHON
|
15.0
|
# Copyright 2015-17 Eficent Business and IT Consulting Services S.L.
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl-3.0).
from odoo import fields, models
class ProductTemplate(models.Model):
_inherit = "product.template"
is_employee = fields.Boolean(string="Is an Employee")
| 33.444444 | 301 |
1,334 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ForgeFlow (https://www.forgeflow.com)
# Copyright 2018-2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2018-2019 Onestein (<https://www.onestein.eu>)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "HR Timesheet Sheet",
"version": "15.0.1.1.0",
"category": "Human Resources",
"sequence": 80,
"summary": "Timesheet Sheets, Activities",
"license": "AGPL-3",
"author": "ForgeFlow, Onestein, CorporateHub, " "Odoo Community Association (OCA)",
"website": "https://github.com/OCA/timesheet",
"installable": True,
"auto_install": False,
"depends": ["hr_timesheet", "sale_timesheet", "web_widget_x2many_2d_matrix"],
"data": [
"data/hr_timesheet_sheet_data.xml",
"security/ir.model.access.csv",
"security/hr_timesheet_sheet_security.xml",
"views/hr_timesheet_sheet_views.xml",
"views/hr_department_views.xml",
"views/hr_employee_views.xml",
"views/account_analytic_line_views.xml",
"views/res_config_settings_views.xml",
],
"assets": {
"web.assets_backend": [
"hr_timesheet_sheet/static/src/js/backend.js",
"hr_timesheet_sheet/static/src/scss/backend.scss",
]
},
}
| 38.114286 | 1,334 |
42,626 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2020 ForgeFlow, S.L.
# Copyright 2018-2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2018-2019 Onestein (<https://www.onestein.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from datetime import date
from dateutil.relativedelta import relativedelta
from odoo import fields
from odoo.exceptions import AccessError, UserError, ValidationError
from odoo.tests.common import Form, TransactionCase
from ..models.hr_timesheet_sheet import empty_name
class TestHrTimesheetSheet(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
officer_group = cls.env.ref("hr.group_hr_user")
multi_company_group = cls.env.ref("base.group_multi_company")
sheet_user_group = cls.env.ref("hr_timesheet.group_hr_timesheet_user")
project_user_group = cls.env.ref("project.group_project_user")
cls.sheet_model = cls.env["hr_timesheet.sheet"].with_context(
tracking_disable=True
)
cls.sheet_line_model = cls.env["hr_timesheet.sheet.line"]
cls.project_model = cls.env["project.project"]
cls.task_model = cls.env["project.task"]
cls.aal_model = cls.env["account.analytic.line"]
cls.aaa_model = cls.env["account.analytic.account"]
cls.employee_model = cls.env["hr.employee"]
cls.department_model = cls.env["hr.department"]
cls.company = cls.env["res.company"].create({"name": "Test company"})
cls.company_2 = cls.env["res.company"].create(
{"name": "Test company 2", "parent_id": cls.company.id}
)
cls.env.user.company_ids += cls.company
cls.env.user.company_ids += cls.company_2
cls.user = (
cls.env["res.users"]
.with_user(cls.env.user)
.with_context(no_reset_password=True)
.create(
{
"name": "Test User",
"login": "test_user",
"email": "[email protected]",
"groups_id": [
(
6,
0,
[
officer_group.id,
sheet_user_group.id,
project_user_group.id,
multi_company_group.id,
],
)
],
"company_id": cls.company.id,
"company_ids": [(4, cls.company.id)],
}
)
)
cls.user_2 = (
cls.env["res.users"]
.with_user(cls.env.user)
.with_context(no_reset_password=True)
.create(
{
"name": "Test User 2",
"login": "test_user_2",
"email": "[email protected]",
"groups_id": [
(
6,
0,
[
officer_group.id,
sheet_user_group.id,
project_user_group.id,
multi_company_group.id,
],
)
],
"company_id": cls.company_2.id,
"company_ids": [(4, cls.company_2.id)],
}
)
)
cls.user_3 = (
cls.env["res.users"]
.with_user(cls.env.user)
.with_context(no_reset_password=True)
.create(
{
"name": "Test User 3",
"login": "test_user_3",
"email": "[email protected]",
"groups_id": [
(
6,
0,
[
sheet_user_group.id,
project_user_group.id,
multi_company_group.id,
],
)
],
"company_id": cls.company.id,
"company_ids": [(4, cls.company.id)],
}
)
)
cls.user_4 = (
cls.env["res.users"]
.with_user(cls.env.user)
.with_context(no_reset_password=True)
.create(
{
"name": "Test User 4",
"login": "test_user_4",
"email": "[email protected]",
"groups_id": [
(
6,
0,
[
officer_group.id,
sheet_user_group.id,
project_user_group.id,
multi_company_group.id,
],
)
],
"company_id": cls.company.id,
"company_ids": [(4, cls.company.id)],
}
)
)
cls.employee_manager = cls.employee_model.create(
{
"name": "Test Manager",
"user_id": cls.user_2.id,
"company_id": cls.user.company_id.id,
}
)
cls.employee = cls.employee_model.create(
{
"name": "Test Employee",
"user_id": cls.user.id,
"parent_id": cls.employee_manager.id,
"company_id": cls.user.company_id.id,
}
)
cls.employee_no_user = cls.employee_model.create(
{
"name": "Test Employee (no user)",
"parent_id": cls.employee_manager.id,
"company_id": cls.user.company_id.id,
}
)
cls.department_manager = cls.employee_model.create(
{
"name": "Test Department Manager",
"user_id": cls.user_3.id,
"company_id": cls.user.company_id.id,
}
)
cls.employee_4 = cls.employee_model.create(
{
"name": "Test User 4",
"user_id": cls.user_4.id,
"parent_id": cls.department_manager.id,
"company_id": cls.user.company_id.id,
}
)
cls.department = cls.department_model.create(
{"name": "Department test", "company_id": cls.user.company_id.id}
)
cls.employee.department_id = cls.department
cls.department_2 = cls.department_model.create(
{
"name": "Department test 2",
"company_id": cls.user.company_id.id,
"manager_id": cls.department_manager.id,
}
)
cls.project_1 = cls.project_model.create(
{
"name": "Project 1",
"company_id": cls.user.company_id.id,
"allow_timesheets": True,
"user_id": cls.user_3.id,
}
)
cls.project_2 = cls.project_model.create(
{
"name": "Project 2",
"company_id": cls.user.company_id.id,
"allow_timesheets": True,
"user_id": cls.user_4.id,
}
)
cls.task_1 = cls.task_model.create(
{
"name": "Task 1",
"project_id": cls.project_1.id,
"company_id": cls.user.company_id.id,
}
)
cls.task_2 = cls.task_model.create(
{
"name": "Task 2",
"project_id": cls.project_2.id,
"company_id": cls.user.company_id.id,
}
)
def test_0(self):
sheet_form = Form(self.sheet_model.with_user(self.user))
self.assertEqual(len(sheet_form.line_ids), 0)
sheet = sheet_form.save()
self.assertEqual(sheet.company_id, self.user.company_id)
self.assertEqual(len(sheet.timesheet_ids), 0)
self.assertEqual(len(sheet.line_ids), 0)
self.assertTrue(sheet.employee_id)
with Form(sheet.with_user(self.user)) as sheet_form:
sheet_form.add_line_project_id = self.project_1
sheet.button_add_line()
# hack: because we cannot call button_add_line in edit mode in the test
sheet.with_context(sheet_write=True)._compute_line_ids()
self.assertEqual(len(sheet.timesheet_ids), 1)
self.assertEqual(len(sheet.line_ids), 7)
def test_1(self):
sheet_form = Form(self.sheet_model.with_user(self.user))
self.assertEqual(sheet_form.employee_id.id, self.employee.id)
self.assertEqual(sheet_form.department_id.id, self.department.id)
self.assertEqual(len(sheet_form.timesheet_ids), 0)
self.assertEqual(len(sheet_form.line_ids), 0)
with sheet_form.timesheet_ids.new() as timesheet:
timesheet.name = "test"
timesheet.project_id = self.project_1
self.assertEqual(sheet_form.employee_id.id, self.employee.id)
self.assertEqual(len(sheet_form.timesheet_ids), 1)
self.assertEqual(len(sheet_form.line_ids), 7)
self.assertFalse(
any([line.get("unit_amount") for line in sheet_form.line_ids._records])
)
timesheet = sheet_form.timesheet_ids._records[0]
self.assertEqual(timesheet.get("unit_amount"), 0)
with sheet_form.timesheet_ids.edit(0) as timesheet:
timesheet.unit_amount = 1.0
self.assertEqual(len(sheet_form.timesheet_ids), 1)
self.assertEqual(len(sheet_form.line_ids), 7)
self.assertTrue(
any([line.get("unit_amount") for line in sheet_form.line_ids._records])
)
sheet = sheet_form.save()
sheet_form = Form(
sheet.with_user(self.user).with_context(
params={"model": "hr_timesheet.sheet", "id": sheet.id}
)
)
lines_to_edit = [
i
for i, x in enumerate(sheet_form.line_ids._records)
if x.get("unit_amount")
]
with sheet_form.line_ids.edit(lines_to_edit[0]) as line:
line.unit_amount = 2.0
line = sheet_form.line_ids._records[lines_to_edit[0]]
self.assertEqual(line.get("unit_amount"), 2.0)
timesheet = sheet_form.timesheet_ids._records[0]
self.assertEqual(timesheet.get("unit_amount"), 1.0)
sheet = sheet_form.save()
self.assertEqual(len(sheet.timesheet_ids), 2)
self.assertEqual(len(sheet.line_ids), 7)
def test_1_B(self):
sheet_form = Form(self.sheet_model.with_user(self.user))
with sheet_form.timesheet_ids.new() as timesheet:
timesheet.name = "test"
timesheet.date = self.sheet_model._default_date_start()
timesheet.project_id = self.project_1
timesheet.unit_amount = 1.0
self.assertEqual(sheet_form.employee_id.id, self.employee.id)
self.assertEqual(len(sheet_form.timesheet_ids), 1)
self.assertEqual(len(sheet_form.line_ids), 7)
self.assertEqual(sheet_form.state, "new")
sheet = sheet_form.save()
self.assertEqual(sheet.state, "draft")
sheet_form = Form(
sheet.with_user(self.user).with_context(
params={"model": "hr_timesheet.sheet", "id": sheet.id}
)
)
with sheet_form.line_ids.new() as line:
line.date = self.sheet_model._default_date_start()
line.project_id = self.project_1
line.employee_id = self.employee
line.unit_amount = 1.0
self.assertEqual(len(sheet_form.timesheet_ids), 1)
self.assertEqual(len(sheet_form.line_ids), 8)
sheet = sheet_form.save()
self.assertEqual(len(sheet.line_ids), 7)
def test_2(self):
sheet = Form(self.sheet_model.with_user(self.user)).save()
self.assertEqual(sheet.department_id.id, self.department.id)
self.assertEqual(len(sheet.timesheet_ids), 0)
self.assertEqual(len(sheet.line_ids), 0)
self.employee._compute_timesheet_sheet_count()
self.assertEqual(self.employee.timesheet_sheet_count, 1)
self.department._compute_timesheet_to_approve()
self.assertEqual(self.department.timesheet_sheet_to_approve_count, 0)
with Form(sheet.with_user(self.user)) as sheet_form:
sheet_form.add_line_project_id = self.project_1
sheet.button_add_line()
# hack: because we cannot call button_add_line in edit mode in the test
sheet.with_context(sheet_write=True)._compute_line_ids()
self.assertFalse(sheet.add_line_project_id.id)
self.assertEqual(len(sheet.line_ids), 7)
self.assertEqual(len(sheet.timesheet_ids), 1)
with Form(sheet.with_user(self.user)) as sheet_form:
with sheet_form.line_ids.edit(0) as line_form:
line_form.unit_amount = 2.0
self.assertEqual(len(sheet.new_line_ids), 1)
line = fields.first(sheet.line_ids)
self.assertEqual(line.unit_amount, 2.0)
self.assertEqual(len(sheet.timesheet_ids), 1)
timesheet = fields.first(sheet.timesheet_ids)
with Form(sheet.with_user(self.user)) as sheet_form:
lines_to_edit = [
i
for i, x in enumerate(sheet_form.line_ids._records)
if x.get("date") != fields.Date.to_string(timesheet.date)
]
with sheet_form.line_ids.edit(lines_to_edit[0]) as line_form:
self.assertEqual(line_form.unit_amount, 0.0)
line_form.unit_amount = 1.0
self.assertEqual(len(sheet.new_line_ids), 1)
line2 = fields.first(
sheet.line_ids.filtered(lambda l: l.date != timesheet.date)
)
self.assertEqual(line2.unit_amount, 1.0)
self.assertEqual(len(sheet.timesheet_ids), 2)
with Form(sheet.with_user(self.user)) as sheet_form:
sheet_form.add_line_project_id = self.project_2
sheet.button_add_line()
# hack: because we cannot call button_add_line in edit mode in the test
sheet.with_context(sheet_write=True)._compute_line_ids()
self.assertEqual(len(sheet.timesheet_ids), 3)
self.assertIn(timesheet.id, sheet.timesheet_ids.ids)
self.assertEqual(len(sheet.line_ids), 14)
self.assertEqual(sheet.state, "draft")
sheet.action_timesheet_confirm()
self.assertEqual(sheet.state, "confirm")
self.department._compute_timesheet_to_approve()
self.assertEqual(self.department.timesheet_sheet_to_approve_count, 1)
# Confirmed timesheet cannot be modified
with self.assertRaises(UserError):
timesheet.unit_amount = 0.0
self.assertEqual(timesheet.unit_amount, 2.0)
# Force confirmed timesheet to be modified
timesheet.with_context(skip_check_state=True).unit_amount = 0.0
self.assertEqual(timesheet.unit_amount, 0.0)
with self.assertRaises(UserError):
timesheet.unlink()
sheet.action_timesheet_done()
self.assertEqual(sheet.state, "done")
with self.assertRaises(UserError):
sheet.unlink()
sheet.action_timesheet_draft()
self.assertEqual(sheet.state, "draft")
sheet.unlink()
def test_3(self):
timesheet = self.aal_model.create(
{
"name": empty_name,
"project_id": self.project_1.id,
"employee_id": self.employee.id,
}
)
sheet_form = Form(self.sheet_model.with_user(self.user))
self.assertEqual(len(sheet_form.line_ids), 7)
self.assertEqual(len(sheet_form.timesheet_ids), 1)
self.assertTrue(self.aal_model.search([("id", "=", timesheet.id)]))
timesheets = [x.get("id") for x in sheet_form.timesheet_ids._records]
sheet = sheet_form.save()
# analytic line cleaned up on form save
self.assertFalse(self.aal_model.search([("id", "in", timesheets)]))
self.assertEqual(len(sheet.line_ids), 0)
self.assertEqual(len(sheet.timesheet_ids), 0)
self.assertFalse(self.aal_model.search([("id", "=", timesheet.id)]))
def test_4(self):
timesheet_1 = self.aal_model.create(
{
"name": empty_name,
"project_id": self.project_1.id,
"employee_id": self.employee.id,
}
)
timesheet_2 = self.aal_model.create(
{
"name": empty_name,
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 1.0,
}
)
timesheet_3 = self.aal_model.create(
{
"name": "x",
"project_id": self.project_1.id,
"employee_id": self.employee.id,
}
)
# With this we assure to be in the same week but different day
# (for covering today = sunday)
days = -1 if timesheet_3.date.weekday() == 6 else 1
timesheet_3.date = timesheet_3.date + relativedelta(days=days)
sheet_form = Form(self.sheet_model.with_user(self.user))
sheet = sheet_form.save()
self.assertEqual(len(sheet.line_ids), 7)
self.assertEqual(len(sheet.timesheet_ids), 2)
timesheet_1_or_2 = self.aal_model.search(
[("id", "in", [timesheet_1.id, timesheet_2.id])]
)
self.assertEqual(len(timesheet_1_or_2), 1)
self.assertEqual(timesheet_1_or_2.unit_amount, 1.0)
self.assertEqual(timesheet_3.unit_amount, 0.0)
line = sheet.line_ids.filtered(lambda l: l.unit_amount != 0.0)
self.assertEqual(len(line), 1)
self.assertEqual(line.unit_amount, 1.0)
with Form(sheet.with_user(self.user)) as sheet_form:
lines_to_edit = [
i
for i, x in enumerate(sheet_form.line_ids._records)
if x.get("unit_amount") != 0.0
]
with sheet_form.line_ids.edit(lines_to_edit[0]) as line_form:
line_form.unit_amount = 0.0
self.assertEqual(len(sheet.new_line_ids), 1)
self.assertEqual(line.unit_amount, 0.0)
self.assertEqual(len(sheet.timesheet_ids), 1)
self.assertFalse(self.aal_model.search([("id", "=", timesheet_1_or_2.id)]))
timesheet_3.name = empty_name
with Form(sheet.with_user(self.user)) as sheet_form:
sheet_form.add_line_project_id = self.project_2
sheet_form.add_line_task_id = self.task_2
sheet.button_add_line()
# hack: because we cannot call button_add_line in edit mode in the test
sheet.with_context(sheet_write=True)._compute_line_ids()
self.assertEqual(len(sheet.timesheet_ids), 1)
self.assertEqual(len(sheet.line_ids), 7)
self.assertFalse(self.aal_model.search([("id", "=", timesheet_3.id)]))
def test_5(self):
timesheet_1 = self.aal_model.create(
{
"name": empty_name,
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 2.0,
}
)
timesheet_2 = self.aal_model.create(
{
"name": "x",
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 2.0,
}
)
sheet_form = Form(self.sheet_model.with_user(self.user))
timesheets = [x.get("id") for x in sheet_form.timesheet_ids._records]
sheet = sheet_form.save()
sheet.timesheet_ids = [(6, 0, timesheets)]
with Form(sheet.with_user(self.user)):
pass # trigger edit and save
self.assertEqual(len(sheet.line_ids), 7)
self.assertEqual(len(sheet.timesheet_ids), 2)
line = sheet.line_ids.filtered(lambda l: l.unit_amount != 0.0)
self.assertEqual(line.unit_amount, 4.0)
timesheet_2.name = empty_name
with Form(sheet.with_user(self.user)) as sheet_form:
lines_to_edit = [
i
for i, x in enumerate(sheet_form.line_ids._records)
if x.get("unit_amount") != 0.0
]
with sheet_form.line_ids.edit(lines_to_edit[0]) as line_form:
line_form.unit_amount = 3.0
self.assertEqual(len(sheet.new_line_ids), 1)
self.assertEqual(len(sheet.timesheet_ids), 1)
self.assertEqual(fields.first(sheet.timesheet_ids).unit_amount, 3.0)
timesheet_1_or_2 = self.aal_model.search(
[("id", "in", [timesheet_1.id, timesheet_2.id])]
)
self.assertEqual(len(timesheet_1_or_2), 1)
self.assertEqual(timesheet_1_or_2.unit_amount, 3.0)
with Form(sheet.with_user(self.user)) as sheet_form:
lines_to_edit = [
i
for i, x in enumerate(sheet_form.line_ids._records)
if x.get("unit_amount") != 0.0
]
with sheet_form.line_ids.edit(lines_to_edit[0]) as line_form:
line_form.unit_amount = 4.0
self.assertEqual(len(sheet.new_line_ids), 1)
self.assertEqual(len(sheet.timesheet_ids), 1)
self.assertEqual(fields.first(sheet.timesheet_ids).unit_amount, 4.0)
self.assertEqual(timesheet_1_or_2.unit_amount, 4.0)
with Form(sheet.with_user(self.user)) as sheet_form:
lines_to_edit = [
i
for i, x in enumerate(sheet_form.line_ids._records)
if x.get("unit_amount") != 0.0
]
with sheet_form.line_ids.edit(lines_to_edit[0]) as line_form:
line_form.unit_amount = -1.0
self.assertEqual(len(sheet.new_line_ids), 1)
self.assertEqual(len(sheet.line_ids), 7)
self.assertEqual(len(sheet.timesheet_ids), 1)
def test_6(self):
timesheet_1 = self.aal_model.create(
{
"name": empty_name,
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 2.0,
}
)
timesheet_2 = self.aal_model.create(
{
"name": "w",
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 2.0,
}
)
timesheet_3 = self.aal_model.create(
{
"name": "x",
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 2.0,
}
)
timesheet_4 = self.aal_model.create(
{
"name": "y",
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 2.0,
}
)
timesheet_5 = self.aal_model.create(
{
"name": "z",
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 2.0,
}
)
sheet_form = Form(self.sheet_model.with_user(self.user))
timesheets = [x.get("id") for x in sheet_form.timesheet_ids._records]
sheet = sheet_form.save()
sheet.timesheet_ids = [(6, 0, timesheets)]
with Form(sheet.with_user(self.user)):
pass # trigger edit and save
self.assertEqual(len(sheet.line_ids), 7)
self.assertEqual(len(sheet.timesheet_ids), 5)
line = sheet.line_ids.filtered(lambda l: l.unit_amount != 0.0)
self.assertEqual(line.unit_amount, 10.0)
timesheet_2.name = empty_name
with Form(sheet.with_user(self.user)) as sheet_form:
lines_to_edit = [
i
for i, x in enumerate(sheet_form.line_ids._records)
if x.get("unit_amount") != 0.0
]
with sheet_form.line_ids.edit(lines_to_edit[0]) as line_form:
line_form.unit_amount = 6.0
self.assertEqual(len(sheet.new_line_ids), 1)
self.assertEqual(len(sheet.timesheet_ids), 3)
timesheet_1_or_2 = self.aal_model.search(
[("id", "in", [timesheet_1.id, timesheet_2.id])]
)
self.assertFalse(timesheet_1_or_2)
with Form(sheet.with_user(self.user)) as sheet_form:
lines_to_edit = [
i
for i, x in enumerate(sheet_form.line_ids._records)
if x.get("unit_amount") != 0.0
]
with sheet_form.line_ids.edit(lines_to_edit[0]) as line_form:
line_form.unit_amount = 3.0
self.assertEqual(len(sheet.new_line_ids), 1)
self.assertEqual(len(sheet.timesheet_ids), 4)
line = sheet.line_ids.filtered(lambda l: l.unit_amount != 0.0)
self.assertEqual(line.unit_amount, 3.0)
timesheet_3_4_and_5 = self.aal_model.search(
[("id", "in", [timesheet_3.id, timesheet_4.id, timesheet_5.id])]
)
self.assertEqual(len(timesheet_3_4_and_5), 3)
timesheet_6 = self.aal_model.create(
{
"name": "z",
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 2.0,
}
)
timesheet_5.name = empty_name
sheet_form = Form(sheet.with_user(self.user))
timesheets = [x.get("id") for x in sheet_form.timesheet_ids._records]
sheet = sheet_form.save()
sheet.timesheet_ids = [(6, 0, timesheets)]
with Form(sheet.with_user(self.user)):
pass # trigger edit and save
self.assertEqual(len(sheet.timesheet_ids), 4)
line = sheet.line_ids.filtered(lambda l: l.unit_amount != 0.0)
self.assertEqual(len(line), 1)
self.assertEqual(line.unit_amount, 5.0)
with Form(sheet.with_user(self.user)) as sheet_form:
lines_to_edit = [
i
for i, x in enumerate(sheet_form.line_ids._records)
if x.get("unit_amount") != 0.0
]
with sheet_form.line_ids.edit(lines_to_edit[0]) as line_form:
line_form.unit_amount = 1.0
self.assertEqual(len(sheet.new_line_ids), 1)
self.assertEqual(len(sheet.timesheet_ids), 4)
self.assertTrue(timesheet_6.exists().ids)
def test_end_date_before_start_date(self):
sheet_form = Form(self.sheet_model.with_user(self.user))
sheet_form.date_start = self.sheet_model._default_date_end()
sheet_form.date_end = self.sheet_model._default_date_start()
self.assertEqual(len(sheet_form.line_ids), 0)
self.assertEqual(len(sheet_form.timesheet_ids), 0)
sheet_form.save()
# self assert something
def test_no_copy(self):
sheet = Form(self.sheet_model.with_user(self.user)).save()
with self.assertRaises(UserError):
sheet.with_user(self.user).copy()
def test_no_overlap(self):
Form(self.sheet_model.with_user(self.user)).save()
with self.assertRaises(ValidationError):
Form(self.sheet_model.with_user(self.user)).save()
def test_8(self):
"""Multicompany test"""
employee_2 = self.employee_model.create(
{
"name": "Test User 2",
"user_id": self.user_2.id,
"company_id": self.user_2.company_id.id,
}
)
department_2 = self.department_model.create(
{"name": "Department test 2", "company_id": self.user_2.company_id.id}
)
project_3 = self.project_model.create(
{"name": "Project 3", "company_id": self.user_2.company_id.id}
)
task_3 = self.task_model.create(
{
"name": "Task 3",
"project_id": project_3.id,
"company_id": self.user_2.company_id.id,
}
)
sheet = Form(self.sheet_model.with_user(self.user)).save()
with self.assertRaises(ValidationError):
with Form(sheet.with_user(self.user)) as sheet_form:
with self.assertRaises(AssertionError):
sheet_form.company_id = self.user_2.company_id.id
with self.assertRaises(AssertionError):
sheet_form.employee_id = employee_2
with self.assertRaises(AssertionError):
sheet_form.department_id = department_2
sheet_form.add_line_project_id = project_3
sheet_form.add_line_task_id = task_3
def test_9(self):
sheet = Form(self.sheet_model.with_user(self.user)).save()
with Form(sheet.with_user(self.user)) as sheet_form:
sheet_form.add_line_project_id = self.project_1
sheet.button_add_line()
# hack: because we cannot call button_add_line in edit mode in the test
sheet.with_context(sheet_write=True)._compute_line_ids()
self.assertEqual(len(sheet.timesheet_ids), 1)
with self.assertRaises(UserError):
sheet.action_timesheet_refuse()
sheet.action_timesheet_confirm()
self.assertEqual(sheet.state, "confirm")
sheet.action_timesheet_refuse()
self.assertEqual(sheet.state, "draft")
sheet.action_timesheet_confirm()
self.assertEqual(sheet.state, "confirm")
sheet.action_timesheet_done()
self.assertEqual(sheet.state, "done")
with self.assertRaises(UserError):
sheet.unlink()
sheet.action_timesheet_draft()
self.assertEqual(sheet.state, "draft")
sheet.unlink()
def test_10_start_day(self):
"""Test that the start day can be configured for weekly timesheets."""
self.company.timesheet_week_start = "6"
sheet = Form(self.sheet_model.with_user(self.user)).save()
weekday_from = sheet.date_start.weekday()
weekday_to = sheet.date_end.weekday()
self.assertEqual(weekday_from, 6, "The timesheet should start on Sunday")
self.assertEqual(weekday_to, 5, "The timesheet should end on Saturday")
def test_11_onchange_unit_amount(self):
"""Test onchange unit_amount for line without sheet_id."""
self.aal_model.create(
{
"name": "test1",
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 2.0,
"date": self.sheet_model._default_date_start(),
}
)
self.aal_model.create(
{
"name": "test2",
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 2.0,
"date": self.sheet_model._default_date_start(),
}
)
sheet_form = Form(self.sheet_model.with_user(self.user))
timesheets = [x.get("id") for x in sheet_form.timesheet_ids._records]
sheet = sheet_form.save()
sheet.timesheet_ids = [(6, 0, timesheets)]
with Form(sheet.with_user(self.user)):
pass # trigger edit and save
self.assertEqual(len(sheet.timesheet_ids), 2)
self.assertEqual(len(sheet.line_ids), 7)
unit_amount = 0.0
for line in sheet.line_ids:
if line.unit_amount:
line.sheet_id = False
unit_amount = line.unit_amount
line.write({"unit_amount": unit_amount + 1.0})
res_onchange = line.with_context(
params={"model": "hr_timesheet.sheet", "id": sheet.id}
).onchange_unit_amount()
self.assertFalse(res_onchange)
self.assertEqual(line.unit_amount, unit_amount + 1.0)
line.sheet_id = sheet.id
self.assertEqual(len(sheet.timesheet_ids), 2)
self.assertEqual(len(sheet.line_ids), 7)
self.assertEqual(len(sheet.new_line_ids), 1)
new_line = fields.first(sheet.new_line_ids)
self.assertEqual(new_line.unit_amount, unit_amount + 1.0)
for line in sheet.line_ids:
if line.unit_amount:
line.sheet_id = False
unit_amount = line.unit_amount
line.write({"unit_amount": unit_amount + 1.0})
res_onchange = line.onchange_unit_amount()
warning = res_onchange.get("warning")
self.assertTrue(warning)
message = warning.get("message")
self.assertTrue(message)
line.sheet_id = sheet.id
def test_12_creating_sheet(self):
"""Test onchange unit_amount for line without sheet_id."""
self.aal_model.create(
{
"name": "test1",
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"unit_amount": 2.0,
"date": self.sheet_model._default_date_start(),
}
)
sheet_form = Form(self.sheet_model.with_user(self.user))
timesheets = [x.get("id") for x in sheet_form.timesheet_ids._records]
sheet = sheet_form.save()
sheet.timesheet_ids = [(6, 0, timesheets)]
with Form(sheet.with_user(self.user)):
pass # trigger edit and save
self.assertEqual(len(sheet.timesheet_ids), 1)
self.assertEqual(len(sheet.line_ids), 7)
line = sheet.line_ids.filtered(lambda l: l.unit_amount)
self.assertEqual(len(line), 1)
self.assertEqual(line.unit_amount, 2.0)
unit_amount = line.unit_amount
with Form(line.with_user(self.user)) as line_form:
line_form.unit_amount = unit_amount + 1.0
self.assertEqual(line.unit_amount, 3.0)
self.assertEqual(len(sheet.timesheet_ids), 1)
self.assertEqual(len(sheet.line_ids), 7)
def test_13(self):
sheet = Form(self.sheet_model.with_user(self.user)).save()
self.assertIsNotNone(sheet.name)
sheet.date_end = sheet.date_start + relativedelta(years=1)
self.assertIsNotNone(sheet.name)
def test_14_analytic_account_multicompany(self):
new_employee = self.employee_model.create(
{
"name": "Test New Employee",
"user_id": self.user_2.id,
"company_id": self.company_2.id,
}
)
sheet = Form(self.sheet_model.with_user(self.user_2)).save()
self.assertEqual(sheet.company_id, self.company_2)
timesheet_1 = self.aal_model.create(
{
"name": "test1",
"project_id": self.project_1.id,
"employee_id": new_employee.id,
"unit_amount": 1.0,
"date": self.sheet_model._default_date_start(),
}
)
with self.assertRaises(ValidationError):
timesheet_1.write({"sheet_id": sheet.id})
new_project = self.project_model.create(
{
"name": "Project Test",
"company_id": self.company_2.id,
"allow_timesheets": True,
}
)
timesheet_2 = self.aal_model.create(
{
"name": "test1",
"project_id": new_project.id,
"employee_id": new_employee.id,
"unit_amount": 1.0,
"date": self.sheet_model._default_date_start(),
}
)
timesheet_2.write({"sheet_id": sheet.id})
def test_15(self):
"""Test company constraint in Account Analytic Account."""
self.aal_model.create(
{
"name": "test1",
"project_id": self.project_1.id,
"employee_id": self.employee.id,
"company_id": self.company.id,
"unit_amount": 2.0,
"date": self.sheet_model._default_date_start(),
}
)
self.assertNotEqual(self.company, self.company_2)
sheet_form = Form(self.sheet_model.with_user(self.user))
timesheets = [x.get("id") for x in sheet_form.timesheet_ids._records]
sheet = sheet_form.save()
sheet.timesheet_ids = [(6, 0, timesheets)]
with Form(sheet.with_user(self.user)):
pass # trigger edit and save
self.assertEqual(sheet.company_id, self.company)
self.assertEqual(len(sheet.timesheet_ids), 1)
self.assertEqual(sheet.timesheet_ids.company_id, self.company)
analytic_account = sheet.timesheet_ids.account_id
self.assertEqual(analytic_account.company_id, self.company)
with self.assertRaises(AccessError):
analytic_account.company_id = self.company_2
def test_16(self):
department = self.department_model.create(
{"name": "Department test", "company_id": False}
)
self.user_16 = (
self.env["res.users"]
.with_user(self.env.user)
.with_context(no_reset_password=True)
.create(
{
"name": "Test User 16",
"login": "test_user_16",
"email": "[email protected]",
"company_id": self.company.id,
"company_ids": [(4, self.company.id)],
}
)
)
new_employee = self.employee_model.create(
{
"name": "Test User",
"user_id": self.user_16.id,
"company_id": self.company.id,
"department_id": department.id,
}
)
sheet_form = Form(self.sheet_model.with_user(self.user))
sheet_form.employee_id = new_employee
sheet_form.department_id = self.department_model
sheet_no_department = sheet_form.save()
self.assertFalse(sheet_no_department.department_id)
sheet_no_department._onchange_employee_id()
self.assertTrue(sheet_no_department.department_id)
self.assertEqual(sheet_no_department.department_id, department)
self.assertTrue(sheet_no_department.company_id)
sheet_no_department.unlink()
sheet_form = Form(self.sheet_model.with_user(self.user))
sheet_form.employee_id = self.employee_model
with self.assertRaises(AssertionError):
sheet_form.save()
sheet_with_employee = Form(self.sheet_model.with_user(self.user)).save()
self.assertTrue(sheet_with_employee.employee_id)
self.assertTrue(sheet_with_employee.department_id)
self.assertTrue(sheet_with_employee.company_id)
def test_sheet_range_monthly(self):
self.company.sheet_range = "MONTHLY"
sheet = Form(self.sheet_model.with_user(self.user)).save()
sheet._compute_name()
self.assertEqual(sheet.date_start.day, 1)
self.assertEqual(sheet.date_start.month, sheet.date_end.month)
def test_sheet_range_daily(self):
self.company.sheet_range = "DAILY"
sheet = Form(self.sheet_model.with_user(self.user)).save()
sheet._compute_name()
self.assertEqual(sheet.date_start, sheet.date_end)
def test_employee_no_user(self):
sheet_form = Form(self.sheet_model.with_user(self.user))
with self.assertRaises(UserError):
sheet_form.employee_id = self.employee_no_user
sheet_form.save()
sheet = Form(self.sheet_model.with_user(self.user)).save()
with Form(sheet.with_user(self.user)) as sheet_form:
with self.assertRaises(AssertionError):
sheet_form.employee_id = self.employee_no_user
def test_workflow(self):
sheet = Form(self.sheet_model.with_user(self.user)).save()
self.sheet_model.with_user(self.user).fields_view_get(view_type="form")
self.sheet_model.with_user(self.user).fields_view_get(view_type="tree")
with self.assertRaises(UserError):
sheet.with_user(self.user_3).action_timesheet_refuse()
with self.assertRaises(UserError):
sheet.with_user(self.user_3).action_timesheet_done()
sheet.action_timesheet_confirm()
self.assertFalse(sheet.with_user(self.user_3).can_review)
self.assertEqual(
self.sheet_model.with_user(self.user_3).search_count(
[("can_review", "=", True)]
),
0,
)
self.assertEqual(
self.sheet_model.with_user(self.user_3).search_count(
[("can_review", "!=", False)]
),
0,
)
self.assertEqual(
self.sheet_model.with_user(self.user_3).search_count(
[("can_review", "=", False)]
),
1,
)
self.assertEqual(
self.sheet_model.with_user(self.user_3).search_count(
[("can_review", "!=", True)]
),
1,
)
with self.assertRaises(UserError):
sheet.with_user(self.user_3).action_timesheet_draft()
sheet.action_timesheet_done()
sheet.action_timesheet_draft()
sheet.unlink()
def test_review_policy_default(self):
self.assertEqual(self.company.timesheet_sheet_review_policy, "hr")
sheet = Form(self.sheet_model.with_user(self.user)).save()
self.assertEqual(sheet.review_policy, "hr")
sheet.unlink()
def test_same_week_different_years(self):
sheet_form = Form(self.sheet_model.with_user(self.user))
sheet_form.date_start = date(2019, 12, 30)
sheet_form.date_end = date(2020, 1, 5)
self.assertEqual(sheet_form.name, "Week 01, 2020")
def test_different_weeks_different_years(self):
sheet_form = Form(self.sheet_model.with_user(self.user))
sheet_form.date_start = date(2019, 12, 29)
sheet_form.date_end = date(2020, 1, 5)
self.assertEqual(sheet_form.name, "Weeks 52, 2019 - 01, 2020")
| 39.178309 | 42,626 |
1,118 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Onestein (<https://www.onestein.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, models
from odoo.exceptions import ValidationError
class AccountAnalyticAccount(models.Model):
_inherit = "account.analytic.account"
@api.constrains("company_id")
def _check_timesheet_sheet_company_id(self):
for rec in self.sudo():
sheets = rec.line_ids.mapped("sheet_id").filtered(
lambda s: s.company_id and s.company_id != rec.company_id
)
if sheets:
raise ValidationError(
_(
"You cannot change the company, "
"as this %(rec_name)s (%(rec_display_name)s) "
"is assigned to %(current_name)s (%(current_display_name)s).",
rec_name=rec._name,
rec_display_name=rec.display_name,
current_name=sheets[0]._name,
current_display_name=sheets[0].display_name,
)
)
| 39.928571 | 1,118 |
2,153 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ForgeFlow, S.L.
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class HrDepartment(models.Model):
_inherit = "hr.department"
timesheet_sheet_to_approve_count = fields.Integer(
compute="_compute_timesheet_to_approve", string="Timesheet Sheets to Approve"
)
def _compute_timesheet_to_approve(self):
timesheet_data = self.env["hr_timesheet.sheet"].read_group(
[("department_id", "in", self.ids), ("state", "=", "confirm")],
["department_id"],
["department_id"],
)
result = {
data["department_id"][0]: data["department_id_count"]
for data in timesheet_data
}
for department in self:
department.timesheet_sheet_to_approve_count = result.get(department.id, 0)
@api.constrains("company_id")
def _check_company_id(self):
for rec in self.sudo().filtered("company_id"):
for field in [
rec.env["hr_timesheet.sheet"].search(
[
("department_id", "=", rec.id),
("company_id", "!=", rec.company_id.id),
("company_id", "!=", False),
],
limit=1,
)
]:
if (
rec.company_id
and field.company_id
and rec.company_id != field.company_id
):
raise ValidationError(
_(
"You cannot change the company, "
"as this %(rec_name)s (%(rec_display_name)s) "
"is assigned to %(current_name)s (%(current_display_name)s).",
rec_name=rec._name,
rec_display_name=rec.display_name,
current_name=field._name,
current_display_name=field.display_name,
)
)
| 38.446429 | 2,153 |
1,090 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ForgeFlow, S.L.
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
_WEEKDAYS = [
("0", "Monday"),
("1", "Tuesday"),
("2", "Wednesday"),
("3", "Thursday"),
("4", "Friday"),
("5", "Saturday"),
("6", "Sunday"),
]
class ResCompany(models.Model):
_inherit = "res.company"
sheet_range = fields.Selection(
[("MONTHLY", "Month"), ("WEEKLY", "Week"), ("DAILY", "Day")],
string="Timesheet Sheet Range",
default="WEEKLY",
help="The range of your Timesheet Sheet.",
)
timesheet_week_start = fields.Selection(
selection=_WEEKDAYS, string="Week start day", default="0"
)
timesheet_sheet_review_policy = fields.Selection(
selection=[
("hr", "By HR Officers"),
("hr_manager", "By HR Managers"),
("timesheet_manager", "By Timesheets Managers"),
],
default="hr",
help="How Timesheet Sheets review is performed.",
)
| 27.948718 | 1,090 |
2,095 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ForgeFlow, S.L.
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class HrEmployee(models.Model):
_inherit = "hr.employee"
timesheet_sheet_ids = fields.One2many(
comodel_name="hr_timesheet.sheet",
inverse_name="employee_id",
string="Timesheet Sheets",
)
timesheet_sheet_count = fields.Integer(
compute="_compute_timesheet_sheet_count", string="Timesheet Sheets Count"
)
def _compute_timesheet_sheet_count(self):
Sheet = self.env["hr_timesheet.sheet"]
for employee in self:
employee.timesheet_sheet_count = Sheet.search_count(
[("employee_id", "=", employee.id)]
)
@api.constrains("company_id")
def _check_company_id(self):
for rec in self.sudo().filtered("company_id"):
for field in [
rec.env["hr_timesheet.sheet"].search(
[
("employee_id", "=", rec.id),
("company_id", "!=", rec.company_id.id),
("company_id", "!=", False),
],
limit=1,
)
]:
if (
rec.company_id
and field.company_id
and rec.company_id != field.company_id
):
raise ValidationError(
_(
"You cannot change the company, "
"as this %(rec_name)s (%(rec_display_name)s) "
"is assigned to %(current_name)s (%(current_display_name)s).",
rec_name=rec._name,
rec_display_name=rec.display_name,
current_name=field._name,
current_display_name=field.display_name,
)
)
| 37.410714 | 2,095 |
32,947 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2020 ForgeFlow, S.L.
# Copyright 2018-2020 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2018-2019 Onestein (<https://www.onestein.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import logging
import re
from collections import namedtuple
from datetime import datetime, time
import babel.dates
from dateutil.relativedelta import SU, relativedelta
from odoo import SUPERUSER_ID, _, api, fields, models
from odoo.exceptions import UserError, ValidationError
_logger = logging.getLogger(__name__)
empty_name = "/"
class Sheet(models.Model):
_name = "hr_timesheet.sheet"
_description = "Timesheet Sheet"
_inherit = ["mail.thread", "mail.activity.mixin", "portal.mixin"]
_table = "hr_timesheet_sheet"
_order = "id desc"
_rec_name = "complete_name"
def _default_date_start(self):
return self._get_period_start(
self.env.user.company_id, fields.Date.context_today(self)
)
def _default_date_end(self):
return self._get_period_end(
self.env.user.company_id, fields.Date.context_today(self)
)
def _selection_review_policy(self):
ResCompany = self.env["res.company"]
return ResCompany._fields["timesheet_sheet_review_policy"].selection
def _default_review_policy(self):
company = self.env.company
return company.timesheet_sheet_review_policy
def _default_employee(self):
company = self.env.company
return self.env["hr.employee"].search(
[("user_id", "=", self.env.uid), ("company_id", "in", [company.id, False])],
limit=1,
order="company_id ASC",
)
def _default_department_id(self):
return self._default_employee().department_id
name = fields.Char(compute="_compute_name")
employee_id = fields.Many2one(
comodel_name="hr.employee",
string="Employee",
default=lambda self: self._default_employee(),
required=True,
readonly=True,
states={"new": [("readonly", False)]},
)
user_id = fields.Many2one(
comodel_name="res.users",
related="employee_id.user_id",
string="User",
store=True,
readonly=True,
)
date_start = fields.Date(
string="Date From",
default=lambda self: self._default_date_start(),
required=True,
index=True,
readonly=True,
states={"new": [("readonly", False)]},
)
date_end = fields.Date(
string="Date To",
default=lambda self: self._default_date_end(),
required=True,
index=True,
readonly=True,
states={"new": [("readonly", False)]},
)
timesheet_ids = fields.One2many(
comodel_name="account.analytic.line",
inverse_name="sheet_id",
string="Timesheets",
readonly=True,
states={"new": [("readonly", False)], "draft": [("readonly", False)]},
)
line_ids = fields.One2many(
comodel_name="hr_timesheet.sheet.line",
compute="_compute_line_ids",
string="Timesheet Sheet Lines",
readonly=True,
states={"new": [("readonly", False)], "draft": [("readonly", False)]},
)
new_line_ids = fields.One2many(
comodel_name="hr_timesheet.sheet.new.analytic.line",
inverse_name="sheet_id",
string="Temporary Timesheets",
readonly=True,
states={"new": [("readonly", False)], "draft": [("readonly", False)]},
)
state = fields.Selection(
[
("new", "New"),
("draft", "Open"),
("confirm", "Waiting Review"),
("done", "Approved"),
],
default="new",
tracking=True,
string="Status",
required=True,
readonly=True,
index=True,
)
company_id = fields.Many2one(
comodel_name="res.company",
string="Company",
default=lambda self: self.env.company,
required=True,
readonly=True,
)
review_policy = fields.Selection(
selection=lambda self: self._selection_review_policy(),
default=lambda self: self._default_review_policy(),
required=True,
readonly=True,
)
department_id = fields.Many2one(
comodel_name="hr.department",
string="Department",
default=lambda self: self._default_department_id(),
readonly=True,
states={"new": [("readonly", False)]},
)
reviewer_id = fields.Many2one(
comodel_name="hr.employee", string="Reviewer", readonly=True, tracking=True
)
add_line_project_id = fields.Many2one(
comodel_name="project.project",
string="Select Project",
help="If selected, the associated project is added "
"to the timesheet sheet when clicked the button.",
)
add_line_task_id = fields.Many2one(
comodel_name="project.task",
string="Select Task",
help="If selected, the associated task is added "
"to the timesheet sheet when clicked the button.",
)
total_time = fields.Float(compute="_compute_total_time", store=True)
can_review = fields.Boolean(
compute="_compute_can_review", search="_search_can_review"
)
complete_name = fields.Char(compute="_compute_complete_name")
@api.depends("date_start", "date_end")
def _compute_name(self):
locale = self.env.context.get("lang") or self.env.user.lang or "en_US"
for sheet in self:
if sheet.date_start == sheet.date_end:
sheet.name = babel.dates.format_skeleton(
skeleton="MMMEd",
datetime=datetime.combine(sheet.date_start, time.min),
locale=locale,
)
continue
period_start = sheet.date_start.strftime("%V, %Y")
period_end = sheet.date_end.strftime("%V, %Y")
if sheet.date_end <= sheet.date_start + relativedelta(weekday=SU):
sheet.name = _("Week %(end)s", end=period_end)
else:
sheet.name = _(
"Weeks %(start)s - %(end)s", start=period_start, end=period_end
)
@api.depends("timesheet_ids.unit_amount")
def _compute_total_time(self):
for sheet in self:
sheet.total_time = sum(sheet.mapped("timesheet_ids.unit_amount"))
@api.depends("review_policy")
def _compute_can_review(self):
for sheet in self:
sheet.can_review = self.env.user in sheet._get_possible_reviewers()
@api.model
def _search_can_review(self, operator, value):
def check_in(users):
return self.env.user in users
def check_not_in(users):
return self.env.user not in users
if (operator == "=" and value) or (operator in ["<>", "!="] and not value):
check = check_in
else:
check = check_not_in
sheets = self.search([]).filtered(
lambda sheet: check(sheet._get_possible_reviewers())
)
return [("id", "in", sheets.ids)]
@api.depends("name", "employee_id")
def _compute_complete_name(self):
for sheet in self:
complete_name = sheet.name
complete_name_components = sheet._get_complete_name_components()
if complete_name_components:
complete_name = "{} ({})".format(
complete_name,
", ".join(complete_name_components),
)
sheet.complete_name = complete_name
@api.constrains("date_start", "date_end")
def _check_start_end_dates(self):
for sheet in self:
if sheet.date_start > sheet.date_end:
raise ValidationError(
_("The start date cannot be later than the end date.")
)
def _get_complete_name_components(self):
"""Hook for extensions"""
self.ensure_one()
return [self.employee_id.name_get()[0][1]]
def _get_overlapping_sheet_domain(self):
"""Hook for extensions"""
self.ensure_one()
return [
("id", "!=", self.id),
("date_start", "<=", self.date_end),
("date_end", ">=", self.date_start),
("employee_id", "=", self.employee_id.id),
("company_id", "=", self._get_timesheet_sheet_company().id),
]
@api.constrains(
"date_start", "date_end", "company_id", "employee_id", "review_policy"
)
def _check_overlapping_sheets(self):
for sheet in self:
overlapping_sheets = self.search(sheet._get_overlapping_sheet_domain())
if overlapping_sheets:
raise ValidationError(
_(
"You cannot have 2 or more sheets that overlap!\n"
'Please use the menu "Timesheet Sheet" '
"to avoid this problem.\nConflicting sheets:\n - %(names)s",
names=(
"\n - ".join(overlapping_sheets.mapped("complete_name")),
),
)
)
@api.constrains("company_id", "employee_id")
def _check_company_id_employee_id(self):
for rec in self.sudo():
if (
rec.company_id
and rec.employee_id.company_id
and rec.company_id != rec.employee_id.company_id
):
raise ValidationError(
_(
"The Company in the Timesheet Sheet and in "
"the Employee must be the same."
)
)
@api.constrains("company_id", "department_id")
def _check_company_id_department_id(self):
for rec in self.sudo():
if (
rec.company_id
and rec.department_id.company_id
and rec.company_id != rec.department_id.company_id
):
raise ValidationError(
_(
"The Company in the Timesheet Sheet and in "
"the Department must be the same."
)
)
@api.constrains("company_id", "add_line_project_id")
def _check_company_id_add_line_project_id(self):
for rec in self.sudo():
if (
rec.company_id
and rec.add_line_project_id.company_id
and rec.company_id != rec.add_line_project_id.company_id
):
raise ValidationError(
_(
"The Company in the Timesheet Sheet and in "
"the Project must be the same."
)
)
@api.constrains("company_id", "add_line_task_id")
def _check_company_id_add_line_task_id(self):
for rec in self.sudo():
if (
rec.company_id
and rec.add_line_task_id.company_id
and rec.company_id != rec.add_line_task_id.company_id
):
raise ValidationError(
_(
"The Company in the Timesheet Sheet and in "
"the Task must be the same."
)
)
def _get_possible_reviewers(self):
self.ensure_one()
res = self.env["res.users"].browse(SUPERUSER_ID)
if self.review_policy == "hr":
res |= self.env.ref("hr.group_hr_user").users
elif self.review_policy == "hr_manager":
res |= self.env.ref("hr.group_hr_manager").users
elif self.review_policy == "timesheet_manager":
res |= self.env.ref("hr_timesheet.group_hr_timesheet_approver").users
return res
def _get_timesheet_sheet_company(self):
self.ensure_one()
employee = self.employee_id
company = employee.company_id or employee.department_id.company_id
if not company:
company = employee.user_id.company_id
return company
@api.onchange("employee_id")
def _onchange_employee_id(self):
if self.employee_id:
company = self._get_timesheet_sheet_company()
self.company_id = company
self.review_policy = company.timesheet_sheet_review_policy
self.department_id = self.employee_id.department_id
def _get_timesheet_sheet_lines_domain(self):
self.ensure_one()
return [
("date", "<=", self.date_end),
("date", ">=", self.date_start),
("employee_id", "=", self.employee_id.id),
("company_id", "=", self._get_timesheet_sheet_company().id),
("project_id", "!=", False),
]
@api.depends("date_start", "date_end")
def _compute_line_ids(self):
SheetLine = self.env["hr_timesheet.sheet.line"]
for sheet in self:
if not all([sheet.date_start, sheet.date_end]):
continue
matrix = sheet._get_data_matrix()
vals_list = []
for key in sorted(matrix, key=lambda key: sheet._get_matrix_sortby(key)):
vals_list.append(sheet._get_default_sheet_line(matrix, key))
if sheet.state in ["new", "draft"]:
sheet.clean_timesheets(matrix[key])
sheet.line_ids = [(6, 0, SheetLine.create(vals_list).ids)]
@api.model
def _matrix_key_attributes(self):
"""Hook for extensions"""
return ["date", "project_id", "task_id"]
@api.model
def _matrix_key(self):
return namedtuple("MatrixKey", self._matrix_key_attributes())
@api.model
def _get_matrix_key_values_for_line(self, aal):
"""Hook for extensions"""
return {"date": aal.date, "project_id": aal.project_id, "task_id": aal.task_id}
@api.model
def _get_matrix_sortby(self, key):
res = []
for attribute in key:
if hasattr(attribute, "name_get"):
name = attribute.name_get()
value = name[0][1] if name else ""
else:
value = attribute
res.append(value)
return res
def _get_data_matrix(self):
self.ensure_one()
MatrixKey = self._matrix_key()
matrix = {}
empty_line = self.env["account.analytic.line"]
for line in self.timesheet_ids:
key = MatrixKey(**self._get_matrix_key_values_for_line(line))
if key not in matrix:
matrix[key] = empty_line
matrix[key] += line
for date in self._get_dates():
for key in matrix.copy():
key = MatrixKey(**{**key._asdict(), "date": date})
if key not in matrix:
matrix[key] = empty_line
return matrix
def _compute_timesheet_ids(self):
AccountAnalyticLines = self.env["account.analytic.line"]
for sheet in self:
domain = sheet._get_timesheet_sheet_lines_domain()
timesheets = AccountAnalyticLines.search(domain)
sheet.link_timesheets_to_sheet(timesheets)
sheet.timesheet_ids = [(6, 0, timesheets.ids)]
@api.onchange("date_start", "date_end", "employee_id")
def _onchange_scope(self):
self._compute_timesheet_ids()
@api.onchange("date_start", "date_end")
def _onchange_dates(self):
if self.date_start > self.date_end:
self.date_end = self.date_start
@api.onchange("timesheet_ids")
def _onchange_timesheets(self):
self._compute_line_ids()
@api.onchange("add_line_project_id")
def onchange_add_project_id(self):
"""Load the project to the timesheet sheet"""
if self.add_line_project_id:
return {
"domain": {
"add_line_task_id": [
("project_id", "=", self.add_line_project_id.id),
("company_id", "=", self.company_id.id),
("id", "not in", self.timesheet_ids.mapped("task_id").ids),
]
}
}
else:
return {"domain": {"add_line_task_id": [("id", "=", False)]}}
@api.model
def _check_employee_user_link(self, vals):
if "employee_id" in vals:
employee = self.env["hr.employee"].sudo().browse(vals["employee_id"])
if not employee.user_id:
raise UserError(
_(
"In order to create a sheet for this employee, you must"
" link him/her to an user: %s"
)
% (employee.name,)
)
return employee.user_id.id
return False
def copy(self, default=None):
if not self.env.context.get("allow_copy_timesheet"):
raise UserError(_("You cannot duplicate a sheet."))
return super().copy(default=default)
@api.model
def create(self, vals):
self._check_employee_user_link(vals)
res = super().create(vals)
res.write({"state": "draft"})
return res
def _sheet_write(self, field, recs):
self.with_context(sheet_write=True).write({field: [(6, 0, recs.ids)]})
def write(self, vals):
self._check_employee_user_link(vals)
res = super().write(vals)
for rec in self:
if rec.state == "draft" and not self.env.context.get("sheet_write"):
rec._update_analytic_lines_from_new_lines(vals)
if "add_line_project_id" not in vals:
rec.delete_empty_lines(True)
return res
def unlink(self):
for sheet in self:
if sheet.state in ("confirm", "done"):
raise UserError(
_(
"You cannot delete a timesheet sheet which is already"
" submitted or confirmed: %s"
)
% (sheet.complete_name,)
)
return super().unlink()
def _get_informables(self):
"""Hook for extensions"""
self.ensure_one()
return self.employee_id.parent_id.user_id.partner_id
def _get_subscribers(self):
"""Hook for extensions"""
self.ensure_one()
subscribers = self._get_possible_reviewers().mapped("partner_id")
subscribers |= self._get_informables()
return subscribers
def _timesheet_subscribe_users(self):
for sheet in self.sudo():
subscribers = sheet._get_subscribers()
if subscribers:
sheet.message_subscribe(partner_ids=subscribers.ids)
def action_timesheet_draft(self):
if self.filtered(lambda sheet: sheet.state != "done"):
raise UserError(_("Cannot revert to draft a non-approved sheet."))
self._check_can_review()
self.write({"state": "draft", "reviewer_id": False})
def action_timesheet_confirm(self):
self._timesheet_subscribe_users()
self.reset_add_line()
self.write({"state": "confirm"})
def action_timesheet_done(self):
if self.filtered(lambda sheet: sheet.state != "confirm"):
raise UserError(_("Cannot approve a non-submitted sheet."))
self._check_can_review()
self.write({"state": "done", "reviewer_id": self._get_current_reviewer().id})
def action_timesheet_refuse(self):
if self.filtered(lambda sheet: sheet.state != "confirm"):
raise UserError(_("Cannot reject a non-submitted sheet."))
self._check_can_review()
self.write({"state": "draft", "reviewer_id": False})
@api.model
def _get_current_reviewer(self):
reviewer = self.env["hr.employee"].search(
[("user_id", "=", self.env.uid)], limit=1
)
if not reviewer:
raise UserError(
_(
"In order to review a timesheet sheet, your user needs to be"
" linked to an employee."
)
)
return reviewer
def _check_can_review(self):
if self.filtered(lambda x: not x.can_review and x.review_policy == "hr"):
raise UserError(_("Only a HR Officer or Manager can review the sheet."))
def button_add_line(self):
for rec in self:
if rec.state in ["new", "draft"]:
rec.add_line()
rec.reset_add_line()
def reset_add_line(self):
self.write({"add_line_project_id": False, "add_line_task_id": False})
def _get_date_name(self, date):
name = babel.dates.format_skeleton(
skeleton="MMMEd",
datetime=datetime.combine(date, time.min),
locale=(self.env.context.get("lang") or self.env.user.lang or "en_US"),
)
name = re.sub(r"(\s*[^\w\d\s])\s+", r"\1\n", name)
name = re.sub(r"([\w\d])\s([\w\d])", "\\1\u00A0\\2", name)
return name
def _get_dates(self):
start = self.date_start
end = self.date_end
if end < start:
return []
dates = [start]
while start != end:
start += relativedelta(days=1)
dates.append(start)
return dates
def _get_line_name(self, project_id, task_id=None, **kwargs):
self.ensure_one()
if task_id:
return "{} - {}".format(
project_id.name_get()[0][1], task_id.name_get()[0][1]
)
return project_id.name_get()[0][1]
def _get_new_line_unique_id(self):
"""Hook for extensions"""
self.ensure_one()
return {
"project_id": self.add_line_project_id,
"task_id": self.add_line_task_id,
}
def _get_default_sheet_line(self, matrix, key):
self.ensure_one()
values = {
"value_x": self._get_date_name(key.date),
"value_y": self._get_line_name(**key._asdict()),
"date": key.date,
"project_id": key.project_id.id,
"task_id": key.task_id.id,
"unit_amount": sum(t.unit_amount for t in matrix[key]),
"employee_id": self.employee_id.id,
"company_id": self.company_id.id,
}
if self.id:
values.update({"sheet_id": self.id})
return values
@api.model
def _prepare_empty_analytic_line(self):
return {
"name": empty_name,
"employee_id": self.employee_id.id,
"date": self.date_start,
"project_id": self.add_line_project_id.id,
"task_id": self.add_line_task_id.id,
"sheet_id": self.id,
"unit_amount": 0.0,
"company_id": self.company_id.id,
}
def add_line(self):
if not self.add_line_project_id:
return
values = self._prepare_empty_analytic_line()
new_line_unique_id = self._get_new_line_unique_id()
existing_unique_ids = list(
{frozenset(line.get_unique_id().items()) for line in self.line_ids}
)
if existing_unique_ids:
self.delete_empty_lines(False)
if frozenset(new_line_unique_id.items()) not in existing_unique_ids:
self.timesheet_ids |= self.env["account.analytic.line"]._sheet_create(
values
)
def link_timesheets_to_sheet(self, timesheets):
self.ensure_one()
if self.id and self.state in ["new", "draft"]:
for aal in timesheets.filtered(lambda a: not a.sheet_id):
aal.write({"sheet_id": self.id})
def clean_timesheets(self, timesheets):
repeated = timesheets.filtered(
lambda t: t.name == empty_name and not t.timesheet_invoice_id
)
if len(repeated) > 1 and self.id:
return repeated.merge_timesheets()
return timesheets
def _is_add_line(self, row):
"""Hook for extensions"""
self.ensure_one()
return (
self.add_line_project_id == row.project_id
and self.add_line_task_id == row.task_id
)
@api.model
def _is_line_of_row(self, aal, row):
"""Hook for extensions"""
return (
aal.project_id.id == row.project_id.id and aal.task_id.id == row.task_id.id
)
def delete_empty_lines(self, delete_empty_rows=False):
self.ensure_one()
for name in list(set(self.line_ids.mapped("value_y"))):
rows = self.line_ids.filtered(lambda l: l.value_y == name)
if not rows:
continue
row = fields.first(rows)
if delete_empty_rows and self._is_add_line(row):
check = any([line.unit_amount for line in rows])
else:
check = not all([line.unit_amount for line in rows])
if not check:
continue
row_lines = self.timesheet_ids.filtered(
lambda aal: self._is_line_of_row(aal, row)
)
row_lines.filtered(
lambda t: t.name == empty_name
and not t.unit_amount
and not t.timesheet_invoice_id
).unlink()
if self.timesheet_ids != self.timesheet_ids.exists():
self._sheet_write("timesheet_ids", self.timesheet_ids.exists())
def _update_analytic_lines_from_new_lines(self, vals):
self.ensure_one()
new_line_ids_list = []
for line in vals.get("line_ids", []):
# Every time we change a value in the grid a new line in line_ids
# is created with the proposed changes, even though the line_ids
# is a computed field. We capture the value of 'new_line_ids'
# in the proposed dict before it disappears.
# This field holds the ids of the transient records
# of model 'hr_timesheet.sheet.new.analytic.line'.
if line[0] == 1 and line[2] and line[2].get("new_line_id"):
new_line_ids_list += [line[2].get("new_line_id")]
for new_line in self.new_line_ids.exists():
if new_line.id in new_line_ids_list:
new_line._update_analytic_lines()
self.new_line_ids.exists().unlink()
self._sheet_write("new_line_ids", self.new_line_ids.exists())
@api.model
def _prepare_new_line(self, line):
"""Hook for extensions"""
return {
"sheet_id": line.sheet_id.id,
"date": line.date,
"project_id": line.project_id.id,
"task_id": line.task_id.id,
"unit_amount": line.unit_amount,
"company_id": line.company_id.id,
"employee_id": line.employee_id.id,
}
def _is_compatible_new_line(self, line_a, line_b):
"""Hook for extensions"""
self.ensure_one()
return (
line_a.project_id.id == line_b.project_id.id
and line_a.task_id.id == line_b.task_id.id
and line_a.date == line_b.date
)
def add_new_line(self, line):
self.ensure_one()
new_line_model = self.env["hr_timesheet.sheet.new.analytic.line"]
new_line = self.new_line_ids.filtered(
lambda l: self._is_compatible_new_line(l, line)
)
if new_line:
new_line.write({"unit_amount": line.unit_amount})
else:
vals = self._prepare_new_line(line)
new_line = new_line_model.create(vals)
self._sheet_write("new_line_ids", self.new_line_ids | new_line)
line.new_line_id = new_line.id
@api.model
def _get_period_start(self, company, date):
r = company and company.sheet_range or "WEEKLY"
if r == "WEEKLY":
if company.timesheet_week_start:
delta = relativedelta(weekday=int(company.timesheet_week_start), days=6)
else:
delta = relativedelta(days=date.weekday())
return date - delta
elif r == "MONTHLY":
return date + relativedelta(day=1)
return date
@api.model
def _get_period_end(self, company, date):
r = company and company.sheet_range or "WEEKLY"
if r == "WEEKLY":
if company.timesheet_week_start:
delta = relativedelta(
weekday=(int(company.timesheet_week_start) + 6) % 7
)
else:
delta = relativedelta(days=6 - date.weekday())
return date + delta
elif r == "MONTHLY":
return date + relativedelta(months=1, day=1, days=-1)
return date
# ------------------------------------------------
# OpenChatter methods and notifications
# ------------------------------------------------
def _track_subtype(self, init_values):
if self:
record = self[0]
if "state" in init_values and record.state == "confirm":
return self.env.ref("hr_timesheet_sheet.mt_timesheet_confirmed")
elif "state" in init_values and record.state == "done":
return self.env.ref("hr_timesheet_sheet.mt_timesheet_approved")
return super()._track_subtype(init_values)
class AbstractSheetLine(models.AbstractModel):
_name = "hr_timesheet.sheet.line.abstract"
_description = "Abstract Timesheet Sheet Line"
sheet_id = fields.Many2one(comodel_name="hr_timesheet.sheet", ondelete="cascade")
date = fields.Date()
project_id = fields.Many2one(comodel_name="project.project", string="Project")
task_id = fields.Many2one(comodel_name="project.task", string="Task")
unit_amount = fields.Float(string="Quantity", default=0.0)
company_id = fields.Many2one(comodel_name="res.company", string="Company")
employee_id = fields.Many2one(comodel_name="hr.employee", string="Employee")
def get_unique_id(self):
"""Hook for extensions"""
self.ensure_one()
return {"project_id": self.project_id, "task_id": self.task_id}
class SheetLine(models.TransientModel):
_name = "hr_timesheet.sheet.line"
_inherit = "hr_timesheet.sheet.line.abstract"
_description = "Timesheet Sheet Line"
value_x = fields.Char(string="Date Name")
value_y = fields.Char(string="Project Name")
new_line_id = fields.Integer(default=0)
@api.onchange("unit_amount")
def onchange_unit_amount(self):
"""This method is called when filling a cell of the matrix."""
self.ensure_one()
sheet = self._get_sheet()
if not sheet:
return {
"warning": {
"title": _("Warning"),
"message": _("Save the Timesheet Sheet first."),
}
}
sheet.add_new_line(self)
@api.model
def _get_sheet(self):
sheet = (self._origin or self).sheet_id
if not sheet:
model = self.env.context.get("params", {}).get("model", "")
obj_id = self.env.context.get("params", {}).get("id")
if model == "hr_timesheet.sheet" and isinstance(obj_id, int):
sheet = self.env["hr_timesheet.sheet"].browse(obj_id)
return sheet
class SheetNewAnalyticLine(models.TransientModel):
_name = "hr_timesheet.sheet.new.analytic.line"
_inherit = "hr_timesheet.sheet.line.abstract"
_description = "Timesheet Sheet New Analytic Line"
@api.model
def _is_similar_analytic_line(self, aal):
"""Hook for extensions"""
return (
aal.date == self.date
and aal.project_id.id == self.project_id.id
and aal.task_id.id == self.task_id.id
)
@api.model
def _update_analytic_lines(self):
sheet = self.sheet_id
timesheets = sheet.timesheet_ids.filtered(
lambda aal: self._is_similar_analytic_line(aal)
)
new_ts = timesheets.filtered(lambda t: t.name == empty_name)
amount = sum(t.unit_amount for t in timesheets)
diff_amount = self.unit_amount - amount
if len(new_ts) > 1:
new_ts = new_ts.merge_timesheets()
sheet._sheet_write("timesheet_ids", sheet.timesheet_ids.exists())
if not diff_amount:
return
if new_ts:
unit_amount = new_ts.unit_amount + diff_amount
if unit_amount:
new_ts.write({"unit_amount": unit_amount})
else:
new_ts.unlink()
sheet._sheet_write("timesheet_ids", sheet.timesheet_ids.exists())
else:
new_ts_values = sheet._prepare_new_line(self)
new_ts_values.update({"name": empty_name, "unit_amount": diff_amount})
self.env["account.analytic.line"]._sheet_create(new_ts_values)
| 36.486157 | 32,947 |
817 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ForgeFlow, S.L.
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResConfig(models.TransientModel):
_inherit = "res.config.settings"
sheet_range = fields.Selection(
related="company_id.sheet_range",
string="Timesheet Sheet Range",
help="The range of your Timesheet Sheet.",
readonly=False,
)
timesheet_week_start = fields.Selection(
related="company_id.timesheet_week_start",
string="Week Start Day",
help="Starting day for Timesheet Sheets.",
readonly=False,
)
timesheet_sheet_review_policy = fields.Selection(
related="company_id.timesheet_sheet_review_policy", readonly=False
)
| 30.259259 | 817 |
4,709 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ForgeFlow, S.L.
# Copyright 2018-2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import UserError, ValidationError
class AccountAnalyticLine(models.Model):
_inherit = "account.analytic.line"
sheet_id = fields.Many2one(comodel_name="hr_timesheet.sheet", string="Sheet")
sheet_state = fields.Selection(string="Sheet State", related="sheet_id.state")
def _get_sheet_domain(self):
"""Hook for extensions"""
self.ensure_one()
return [
("date_end", ">=", self.date),
("date_start", "<=", self.date),
("employee_id", "=", self.employee_id.id),
("company_id", "in", [self.company_id.id, False]),
("state", "in", ["new", "draft"]),
]
def _determine_sheet(self):
"""Hook for extensions"""
self.ensure_one()
return self.env["hr_timesheet.sheet"].search(self._get_sheet_domain(), limit=1)
def _compute_sheet(self):
"""Links the timesheet line to the corresponding sheet"""
for timesheet in self.filtered("project_id"):
sheet = timesheet._determine_sheet()
if timesheet.sheet_id != sheet:
timesheet.sheet_id = sheet
@api.constrains("company_id", "sheet_id")
def _check_company_id_sheet_id(self):
for aal in self.sudo():
if (
aal.company_id
and aal.sheet_id.company_id
and aal.company_id != aal.sheet_id.company_id
):
raise ValidationError(
_(
"You cannot create a timesheet of a different company "
"than the one of the timesheet sheet:"
"\n - %(sheet_name)s of %(sheet_company)s"
"\n - %(name)s of %(company)s",
sheet_name=aal.sheet_id.complete_name,
sheet_company=aal.sheet_id.company_id.name,
name=aal.name,
company=aal.company_id.name,
)
)
@api.model
def create(self, values):
if not self.env.context.get("sheet_create") and "sheet_id" in values:
del values["sheet_id"]
res = super().create(values)
res._compute_sheet()
return res
@api.model
def _sheet_create(self, values):
return self.with_context(sheet_create=True).create(values)
def write(self, values):
self._check_state_on_write(values)
res = super().write(values)
if self._timesheet_should_compute_sheet(values):
self._compute_sheet()
return res
def unlink(self):
self._check_state()
return super().unlink()
def _check_state_on_write(self, values):
"""Hook for extensions"""
if self._timesheet_should_check_write(values):
self._check_state()
@api.model
def _timesheet_should_check_write(self, values):
"""Hook for extensions"""
return bool(set(self._get_timesheet_protected_fields()) & set(values.keys()))
@api.model
def _timesheet_should_compute_sheet(self, values):
"""Hook for extensions"""
return any(f in self._get_sheet_affecting_fields() for f in values)
@api.model
def _get_timesheet_protected_fields(self):
"""Hook for extensions"""
return [
"name",
"date",
"unit_amount",
"user_id",
"employee_id",
"department_id",
"company_id",
"task_id",
"project_id",
"sheet_id",
]
@api.model
def _get_sheet_affecting_fields(self):
"""Hook for extensions"""
return ["date", "employee_id", "project_id", "company_id"]
def _check_state(self):
if self.env.context.get("skip_check_state"):
return
for line in self.exists().filtered("sheet_id"):
if line.sheet_id.state not in ["new", "draft"]:
raise UserError(
_(
"You cannot modify an entry in a confirmed timesheet sheet"
": %(names)s",
names=line.sheet_id.complete_name,
)
)
def merge_timesheets(self):
unit_amount = sum(t.unit_amount for t in self)
amount = sum(t.amount for t in self)
self[0].write({"unit_amount": unit_amount, "amount": amount})
self[1:].unlink()
return self[0]
| 34.625 | 4,709 |
700 |
py
|
PYTHON
|
15.0
|
# Copyright 2016-2017 ACSONE SA/NV
# Copyright 2018-2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Hr Timesheet Task Required",
"summary": """
Set task on timesheet as a mandatory field""",
"version": "15.0.1.0.0",
"license": "AGPL-3",
"author": "ACSONE SA/NV, CorporateHub, Odoo Community Association (OCA)",
"website": "https://github.com/OCA/timesheet",
"depends": ["hr_timesheet"],
"data": [
"views/account_analytic_line.xml",
"views/project_project.xml",
"views/res_config_settings.xml",
],
}
| 35 | 700 |
1,847 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ACSONE SA/NV
# Copyright 2018-2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.exceptions import ValidationError
from odoo.tests import SavepointCase
class TestHrTimesheetTaskRequired(SavepointCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.AnalyticLine = cls.env["account.analytic.line"]
cls.Project = cls.env["project.project"]
cls.ProjectTask = cls.env["project.task"]
cls.project_1 = cls.Project.create(
{"name": "Project 1", "is_timesheet_task_required": True}
)
cls.project_2 = cls.Project.create({"name": "Project 2"})
cls.task_1_p1 = cls.ProjectTask.create(
{"name": "Task 1-1", "project_id": cls.project_1.id}
)
cls.task_1_p2 = cls.ProjectTask.create(
{"name": "Task 2-1", "project_id": cls.project_2.id}
)
def test_timesheet_line_task_required(self):
with self.assertRaises(ValidationError):
self.AnalyticLine.create(
{"name": "test", "project_id": self.project_1.id, "unit_amount": 10}
)
self.AnalyticLine.create(
{
"name": "test",
"project_id": self.project_1.id,
"task_id": self.task_1_p1.id,
"unit_amount": 10,
}
)
def test_timesheet_line_task_not_required(self):
self.AnalyticLine.create(
{"name": "test", "project_id": self.project_2.id, "unit_amount": 10}
)
self.AnalyticLine.create(
{
"name": "test",
"project_id": self.project_2.id,
"task_id": self.task_1_p2.id,
"unit_amount": 10,
}
)
| 32.982143 | 1,847 |
313 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResCompany(models.Model):
_inherit = "res.company"
is_timesheet_task_required = fields.Boolean(string="Require Tasks on Timesheets")
| 31.3 | 313 |
433 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
is_timesheet_task_required = fields.Boolean(
string="Require Tasks on Timesheets",
related="company_id.is_timesheet_task_required",
readonly=False,
)
| 30.928571 | 433 |
664 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class ProjectProject(models.Model):
_inherit = "project.project"
is_timesheet_task_required = fields.Boolean(
string="Require Tasks on Timesheets",
default=lambda self: self._default_is_timesheet_task_required(),
)
@api.model
def _default_is_timesheet_task_required(self):
company = self.env["res.company"].browse(
self._context.get("company_id", self.env.user.company_id.id)
)
return company.is_timesheet_task_required
| 33.2 | 664 |
713 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ACSONE SA/NV
# Copyright 2018-2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class AccountAnalyticLine(models.Model):
_inherit = "account.analytic.line"
is_task_required = fields.Boolean(
string="Is Task Required", related="project_id.is_timesheet_task_required"
)
@api.constrains("project_id", "task_id")
def _check_timesheet_task(self):
for line in self:
if line.is_task_required and not line.task_id:
raise ValidationError(_("You must specify a task for timesheet lines."))
| 35.65 | 713 |
642 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Sales Timesheet: exclude Task from Sale Order",
"version": "15.0.1.0.1",
"category": "Sales",
"website": "https://github.com/OCA/timesheet",
"author": "CorporateHub, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"application": False,
"summary": "Exclude Task and related Timesheets from Sale Order",
"depends": ["sale_timesheet"],
"data": ["views/project_task.xml"],
}
| 37.764706 | 642 |
5,886 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.tests import common
class TestSaleTimesheetExcludeTask(common.TransactionCase):
def setUp(self):
super().setUp()
self.uom_hour = self.env.ref("uom.product_uom_hour")
self.user_type_payable = self.env.ref("account.data_account_type_payable")
self.user_type_receivable = self.env.ref("account.data_account_type_receivable")
self.user_type_revenue = self.env.ref("account.data_account_type_revenue")
self.Partner = self.env["res.partner"]
self.SudoPartner = self.Partner.sudo()
self.Employee = self.env["hr.employee"]
self.SudoEmployee = self.Employee.sudo()
self.AccountAccount = self.env["account.account"]
self.SudoAccountAccount = self.AccountAccount.sudo()
self.Project = self.env["project.project"]
self.SudoProject = self.Project.sudo()
self.ProjectTask = self.env["project.task"]
self.SudoProjectTask = self.ProjectTask.sudo()
self.AccountAnalyticLine = self.env["account.analytic.line"]
self.SudoAccountAnalyticLine = self.AccountAnalyticLine.sudo()
self.ProductProduct = self.env["product.product"]
self.SudoProductProduct = self.ProductProduct.sudo()
self.SaleOrder = self.env["sale.order"]
self.SudoSaleOrder = self.SaleOrder.sudo()
self.SaleOrderLine = self.env["sale.order.line"]
self.SudoSaleOrderLine = self.SaleOrderLine.sudo()
self.ProjectCreateSaleOrder = self.env["project.create.sale.order"]
self.analytic_account_sale = self.env["account.analytic.account"].create(
{
"name": "Project for selling timesheet - AA",
"code": "AA-20300",
"company_id": self.env.company.id,
}
)
def test_exclude_from_sale_order(self):
account = self.SudoAccountAccount.create(
{
"code": "TEST-1",
"name": "Sales #1",
"reconcile": True,
"user_type_id": self.user_type_revenue.id,
}
)
project = self.SudoProject.create(
{
"name": "Project #1",
"allow_timesheets": True,
"allow_billable": True,
"analytic_account_id": self.analytic_account_sale.id,
}
)
product = self.SudoProductProduct.create(
{
"name": "Service #1",
"standard_price": 30,
"list_price": 90,
"type": "service",
"invoice_policy": "delivery",
"uom_id": self.uom_hour.id,
"uom_po_id": self.uom_hour.id,
"default_code": "CODE-1",
"service_type": "timesheet",
"service_tracking": "task_global_project",
"project_id": project.id,
"taxes_id": False,
"property_account_income_id": account.id,
}
)
employee = self.SudoEmployee.create(
{"name": "Employee #1", "timesheet_cost": 42}
)
account_payable = self.SudoAccountAccount.create(
{
"code": "AP1",
"name": "Payable #1",
"user_type_id": self.user_type_payable.id,
"reconcile": True,
}
)
account_receivable = self.SudoAccountAccount.create(
{
"code": "AR1",
"name": "Receivable #1",
"user_type_id": self.user_type_receivable.id,
"reconcile": True,
}
)
partner = self.SudoPartner.create(
{
"name": "Partner #1",
"email": "partner1@localhost",
"property_account_payable_id": account_payable.id,
"property_account_receivable_id": account_receivable.id,
}
)
sale_order = self.SudoSaleOrder.create(
{
"partner_id": partner.id,
"partner_invoice_id": partner.id,
"partner_shipping_id": partner.id,
}
)
sale_order_line = self.SudoSaleOrderLine.create(
{
"order_id": sale_order.id,
"name": product.name,
"product_id": product.id,
"product_uom_qty": 2,
"product_uom": self.uom_hour.id,
"price_unit": product.list_price,
}
)
sale_order.action_confirm()
task = self.SudoProjectTask.search([("sale_line_id", "=", sale_order_line.id)])
timesheet = self.SudoAccountAnalyticLine.create(
{
"project_id": task.project_id.id,
"task_id": task.id,
"name": "Entry #1",
"unit_amount": 1,
"employee_id": employee.id,
"account_id": project.analytic_account_id.id,
}
)
task.exclude_from_sale_order = True
task.allow_billable = False
self.assertFalse(timesheet.so_line)
task.write({"exclude_from_sale_order": False, "allow_billable": True})
self.assertTrue(timesheet.so_line)
payment = (
self.env["sale.advance.payment.inv"]
.with_context(
**{
"active_model": "sale.order",
"active_ids": [sale_order.id],
"active_id": sale_order.id,
}
)
.create({"advance_payment_method": "delivered"})
)
payment.create_invoices()
task.exclude_from_sale_order = True
self.assertTrue(timesheet.so_line)
| 38.723684 | 5,886 |
1,322 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class ProjectTask(models.Model):
_inherit = "project.task"
exclude_from_sale_order = fields.Boolean(
string="Exclude from Sale Order",
help=(
"Checking this would exclude any timesheet entries logged towards"
" this task from Sale Order"
),
)
@api.depends(
"sale_line_id",
"project_id",
"allow_billable",
"commercial_partner_id",
"exclude_from_sale_order",
)
def _compute_sale_order_id(self):
res = super(ProjectTask, self)._compute_sale_order_id()
excluded = self.filtered("exclude_from_sale_order")
for task in excluded:
task.sale_order_id = False
return res
def write(self, vals):
res = super().write(vals)
if "exclude_from_sale_order" in vals:
# If tasks changed their exclude_from_sale_order, update all AALs
# that have not been invoiced yet
for timesheet in self.mapped("timesheet_ids").filtered(
lambda line: not line.timesheet_invoice_id
):
timesheet._compute_so_line()
return res
| 32.243902 | 1,322 |
682 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2019 Brainbean Apps (https://brainbeanapps.com)
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Sales Timesheet: exclude Timesheet Line from Sale Order",
"version": "15.0.1.0.0",
"category": "Sales",
"website": "https://github.com/OCA/timesheet",
"author": "CorporateHub, " "Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"application": False,
"summary": "Exclude Timesheet Line from Sale Order",
"depends": ["sale_timesheet"],
"data": ["views/account_analytic_line.xml", "views/project_task.xml"],
}
| 40.117647 | 682 |
13,975 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2019 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo.exceptions import ValidationError
from odoo.tests import common
class TestSaleTimesheetLineExclude(common.TransactionCase):
def setUp(self):
super().setUp()
self.uom_hour = self.env.ref("uom.product_uom_hour")
self.user_type_payable = self.env.ref("account.data_account_type_payable")
self.user_type_receivable = self.env.ref("account.data_account_type_receivable")
self.user_type_revenue = self.env.ref("account.data_account_type_revenue")
self.Partner = self.env["res.partner"]
self.SudoPartner = self.Partner.sudo()
self.Employee = self.env["hr.employee"]
self.SudoEmployee = self.Employee.sudo()
self.AccountAccount = self.env["account.account"]
self.SudoAccountAccount = self.AccountAccount.sudo()
self.Project = self.env["project.project"]
self.SudoProject = self.Project.sudo()
self.ProjectTask = self.env["project.task"]
self.SudoProjectTask = self.ProjectTask.sudo()
self.AccountAnalyticLine = self.env["account.analytic.line"]
self.SudoAccountAnalyticLine = self.AccountAnalyticLine.sudo()
self.ProductProduct = self.env["product.product"]
self.SudoProductProduct = self.ProductProduct.sudo()
self.SaleOrder = self.env["sale.order"]
self.SudoSaleOrder = self.SaleOrder.sudo()
self.SaleOrderLine = self.env["sale.order.line"]
self.SudoSaleOrderLine = self.SaleOrderLine.sudo()
self.ProjectCreateSaleOrder = self.env["project.create.sale.order"]
self.analytic_account_sale = self.env["account.analytic.account"].create(
{
"name": "Project for selling timesheet - AA",
"code": "AA-20300",
"company_id": self.env.company.id,
}
)
self.account = self.SudoAccountAccount.create(
{
"code": "TEST-1",
"name": "Sales #1",
"reconcile": True,
"user_type_id": self.user_type_revenue.id,
}
)
self.project = self.SudoProject.create(
{
"name": "Project #1",
"allow_timesheets": True,
"analytic_account_id": self.analytic_account_sale.id,
"allow_billable": True,
}
)
self.product = self.SudoProductProduct.create(
{
"name": "Service #1",
"standard_price": 30,
"list_price": 90,
"type": "service",
"invoice_policy": "delivery",
"uom_id": self.uom_hour.id,
"uom_po_id": self.uom_hour.id,
"default_code": "CODE-1",
"service_type": "timesheet",
"service_tracking": "task_global_project",
"project_id": self.project.id,
"taxes_id": False,
"property_account_income_id": self.account.id,
}
)
self.employee = self.SudoEmployee.create(
{"name": "Employee #1", "timesheet_cost": 42}
)
self.account_payable = self.SudoAccountAccount.create(
{
"code": "AP4",
"name": "Payable #1",
"user_type_id": self.user_type_payable.id,
"reconcile": True,
}
)
self.account_receivable = self.SudoAccountAccount.create(
{
"code": "AR1",
"name": "Receivable #1",
"user_type_id": self.user_type_receivable.id,
"reconcile": True,
}
)
self.partner = self.SudoPartner.create(
{
"name": "Partner #1",
"email": "partner1@localhost",
"property_account_payable_id": self.account_payable.id,
"property_account_receivable_id": self.account_receivable.id,
}
)
self.sale_order = self.SudoSaleOrder.create(
{
"partner_id": self.partner.id,
"partner_invoice_id": self.partner.id,
"partner_shipping_id": self.partner.id,
}
)
self.sale_order_line = self.SudoSaleOrderLine.create(
{
"order_id": self.sale_order.id,
"name": self.product.name,
"product_id": self.product.id,
"product_uom_qty": 2,
"product_uom": self.uom_hour.id,
"price_unit": self.product.list_price,
}
)
self.sale_order.action_confirm()
self.task = self.SudoProjectTask.search(
[("sale_line_id", "=", self.sale_order_line.id)]
)
def test_create_without_exclude_from_sale_order(self):
timesheet = self.SudoAccountAnalyticLine.create(
{
"project_id": self.task.project_id.id,
"task_id": self.task.id,
"name": "Entry #1-1",
"unit_amount": 1,
"employee_id": self.employee.id,
"account_id": self.project.analytic_account_id.id,
}
)
self.assertEqual(timesheet.timesheet_invoice_type, "billable_time")
self.assertEqual(self.sale_order_line.qty_delivered, 1)
self.assertEqual(self.sale_order_line.qty_to_invoice, 1)
self.assertEqual(self.sale_order_line.qty_invoiced, 0)
def test_create_with_exclude_from_sale_order(self):
timesheet = self.SudoAccountAnalyticLine.create(
{
"project_id": self.task.project_id.id,
"task_id": self.task.id,
"name": "Entry #1-1",
"unit_amount": 1,
"employee_id": self.employee.id,
"exclude_from_sale_order": True,
"account_id": self.project.analytic_account_id.id,
}
)
self.assertEqual(timesheet.timesheet_invoice_type, "non_billable")
self.assertEqual(self.sale_order_line.qty_delivered, 0)
self.assertEqual(self.sale_order_line.qty_to_invoice, 0)
self.assertEqual(self.sale_order_line.qty_invoiced, 0)
def test_write_exclude_from_sale_order(self):
timesheet = self.SudoAccountAnalyticLine.create(
{
"project_id": self.task.project_id.id,
"task_id": self.task.id,
"name": "Entry #1-1",
"unit_amount": 1,
"employee_id": self.employee.id,
"exclude_from_sale_order": False,
"account_id": self.project.analytic_account_id.id,
}
)
timesheet.write({"exclude_from_sale_order": True})
self.assertEqual(timesheet.timesheet_invoice_type, "non_billable")
self.assertEqual(self.sale_order_line.qty_delivered, 0)
self.assertEqual(self.sale_order_line.qty_to_invoice, 0)
self.assertEqual(self.sale_order_line.qty_invoiced, 0)
def test_write_remove_exclude_from_sale_order(self):
timesheet = self.SudoAccountAnalyticLine.create(
{
"project_id": self.task.project_id.id,
"task_id": self.task.id,
"name": "Entry #1-1",
"unit_amount": 1,
"employee_id": self.employee.id,
"exclude_from_sale_order": True,
"account_id": self.project.analytic_account_id.id,
}
)
timesheet.write({"exclude_from_sale_order": False})
self.assertTrue(timesheet.so_line)
self.assertEqual(timesheet.timesheet_invoice_type, "billable_time")
self.assertEqual(self.sale_order_line.qty_delivered, 1)
self.assertEqual(self.sale_order_line.qty_to_invoice, 1)
self.assertEqual(self.sale_order_line.qty_invoiced, 0)
def test_create_invoice(self):
timesheet1 = self.SudoAccountAnalyticLine.create(
{
"project_id": self.task.project_id.id,
"task_id": self.task.id,
"name": "Entry #1-1",
"unit_amount": 1,
"employee_id": self.employee.id,
"account_id": self.project.analytic_account_id.id,
}
)
timesheet2 = self.SudoAccountAnalyticLine.create(
{
"project_id": self.task.project_id.id,
"task_id": self.task.id,
"name": "Entry #1-1",
"unit_amount": 1,
"employee_id": self.employee.id,
"exclude_from_sale_order": True,
"account_id": self.project.analytic_account_id.id,
}
)
self.assertEqual(timesheet1.timesheet_invoice_type, "billable_time")
self.assertEqual(timesheet2.timesheet_invoice_type, "non_billable")
self.assertEqual(self.sale_order_line.qty_delivered, 1)
self.assertEqual(self.sale_order_line.qty_to_invoice, 1)
self.assertEqual(self.sale_order_line.qty_invoiced, 0)
self.sale_order._create_invoices()
self.assertTrue(timesheet1.timesheet_invoice_id)
self.assertEqual(self.sale_order_line.qty_delivered, 1)
self.assertEqual(self.sale_order_line.qty_to_invoice, 0)
self.assertEqual(self.sale_order_line.qty_invoiced, 1)
def test_write_invoiced(self):
timesheet1 = self.SudoAccountAnalyticLine.create(
{
"project_id": self.task.project_id.id,
"task_id": self.task.id,
"name": "Entry #1-1",
"unit_amount": 1,
"employee_id": self.employee.id,
"account_id": self.project.analytic_account_id.id,
}
)
timesheet2 = self.SudoAccountAnalyticLine.create(
{
"project_id": self.task.project_id.id,
"task_id": self.task.id,
"name": "Entry #1-1",
"unit_amount": 1,
"employee_id": self.employee.id,
"exclude_from_sale_order": True,
"account_id": self.project.analytic_account_id.id,
}
)
self.assertEqual(timesheet1.timesheet_invoice_type, "billable_time")
self.assertEqual(timesheet2.timesheet_invoice_type, "non_billable")
self.assertEqual(self.sale_order_line.qty_delivered, 1)
self.assertEqual(self.sale_order_line.qty_to_invoice, 1)
self.assertEqual(self.sale_order_line.qty_invoiced, 0)
self.sale_order._create_invoices()
self.assertTrue(timesheet1.timesheet_invoice_id)
self.assertEqual(self.sale_order_line.qty_delivered, 1)
self.assertEqual(self.sale_order_line.qty_to_invoice, 0)
self.assertEqual(self.sale_order_line.qty_invoiced, 1)
with self.assertRaises(ValidationError):
timesheet1.write({"exclude_from_sale_order": True})
def test_1(self):
timesheet1 = self.SudoAccountAnalyticLine.create(
{
"project_id": self.task.project_id.id,
"task_id": self.task.id,
"name": "Entry #1-1",
"unit_amount": 1,
"employee_id": self.employee.id,
"account_id": self.project.analytic_account_id.id,
}
)
timesheet2 = self.SudoAccountAnalyticLine.create(
{
"project_id": self.task.project_id.id,
"task_id": self.task.id,
"name": "Entry #1-2",
"unit_amount": 1,
"employee_id": self.employee.id,
"exclude_from_sale_order": False,
"account_id": self.project.analytic_account_id.id,
}
)
self.assertEqual(timesheet1.timesheet_invoice_type, "billable_time")
self.assertEqual(timesheet2.timesheet_invoice_type, "billable_time")
self.assertEqual(self.sale_order_line.qty_delivered, 2)
self.assertEqual(self.sale_order_line.qty_to_invoice, 2)
self.assertEqual(self.sale_order_line.qty_invoiced, 0)
timesheet3 = self.SudoAccountAnalyticLine.create(
{
"project_id": self.task.project_id.id,
"task_id": self.task.id,
"name": "Entry #1-3",
"unit_amount": 1,
"employee_id": self.employee.id,
"account_id": self.project.analytic_account_id.id,
}
)
self.assertEqual(timesheet3.timesheet_invoice_type, "billable_time")
self.assertTrue(timesheet3.so_line)
self.assertEqual(self.sale_order_line.qty_delivered, 3)
self.assertEqual(self.sale_order_line.qty_to_invoice, 3)
self.assertEqual(self.sale_order_line.qty_invoiced, 0)
self.assertEqual(timesheet1.timesheet_invoice_type, "billable_time")
self.assertTrue(timesheet1.so_line)
timesheet2.write({"exclude_from_sale_order": True})
self.assertEqual(timesheet2.timesheet_invoice_type, "non_billable")
self.assertFalse(timesheet2.so_line)
self.assertEqual(self.sale_order_line.qty_delivered, 2)
self.assertEqual(self.sale_order_line.qty_to_invoice, 2)
self.assertEqual(self.sale_order_line.qty_invoiced, 0)
self.assertFalse(timesheet1.timesheet_invoice_id)
self.sale_order._create_invoices()
self.assertTrue(timesheet1.timesheet_invoice_id)
self.assertEqual(self.sale_order_line.qty_delivered, 2)
self.assertEqual(self.sale_order_line.qty_to_invoice, 0)
self.assertEqual(self.sale_order_line.qty_invoiced, 2)
with self.assertRaises(ValidationError):
timesheet1.write({"exclude_from_sale_order": True})
| 41.966967 | 13,975 |
1,778 |
py
|
PYTHON
|
15.0
|
# Copyright 2018-2019 Brainbean Apps
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class AccountAnalyticLine(models.Model):
_inherit = "account.analytic.line"
exclude_from_sale_order = fields.Boolean(
string="Non-billable",
help="Checking this would exclude this timesheet entry from Sale Order",
)
@api.constrains("exclude_from_sale_order")
def _constrains_exclude_from_sale_order(self):
for line in self:
if (
line.timesheet_invoice_id
and line.so_line.product_id.invoice_policy == "delivery"
):
raise ValidationError(
_(
"You can not modify timesheets in a way that would affect "
"invoices since these timesheets were already invoiced."
)
)
@api.depends("exclude_from_sale_order")
def _compute_timesheet_invoice_type(self):
result = super()._compute_timesheet_invoice_type()
for line in self:
if line.exclude_from_sale_order:
line.timesheet_invoice_type = "non_billable"
return result
@api.depends("exclude_from_sale_order")
def _compute_so_line_on_exclude(self):
self._compute_so_line()
def _timesheet_determine_sale_line(self):
self.ensure_one()
if self.exclude_from_sale_order:
return False
return super()._timesheet_determine_sale_line()
def _timesheet_postprocess(self, values):
if "exclude_from_sale_order" in values:
self._compute_so_line()
return super()._timesheet_postprocess(values)
| 34.862745 | 1,778 |
752 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Helpdesk Management - Nonconformity",
"summary": "Links helpdesk tickets with nonconformities",
"version": "15.0.1.0.0",
"category": "After-Sales",
"website": "https://github.com/OCA/helpdesk",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"depends": ["helpdesk_mgmt", "mgmtsystem_nonconformity"],
"data": [
"data/helpdesk_ticket_stage.xml",
"views/helpdesk_ticket_view.xml",
"views/helpdesk_ticket_stage_view.xml",
"views/mgmtsystem_nonconformity_view.xml",
],
"installable": True,
"maintainers": ["victoralmau"],
}
| 37.5 | 750 |
1,974 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.tests import common
class TestMgmtsystemNonconformity(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.nonconformity_stage_1 = cls.env["mgmtsystem.nonconformity.stage"].create(
{"name": "Stage 1"}
)
cls.nonconformity_stage_2 = cls.nonconformity_stage_1.copy({"name": "Stage 2"})
cls.nonconformity_stage_3 = cls.nonconformity_stage_2.copy({"name": "Stage 3"})
cls.ticket_stage_1 = cls.env["helpdesk.ticket.stage"].create(
{"name": "Stage 1", "nonconformity_stage_id": cls.nonconformity_stage_1.id}
)
cls.ticket_stage_2 = cls.ticket_stage_1.copy(
{"name": "Stage 2", "nonconformity_stage_id": cls.nonconformity_stage_2.id}
)
cls.partner = cls.env["res.partner"].create({"name": "Mr Odoo"})
def test_create_ticket(self):
ticket = self.env["helpdesk.ticket"].create(
{
"name": "Test ticket",
"partner_id": self.partner.id,
"user_id": self.env.ref("base.user_admin").id,
"description": "description",
"stage_id": self.ticket_stage_1.id,
}
)
self.assertFalse(ticket.nonconformity_id)
ticket.action_nonconformity_create()
self.assertTrue(ticket.nonconformity_id)
self.assertEqual(ticket.nonconformity_id.stage_id, self.nonconformity_stage_1)
ticket.stage_id = self.ticket_stage_2
self.assertEqual(ticket.nonconformity_id.stage_id, self.nonconformity_stage_2)
ticket.nonconformity_id.stage_id = self.nonconformity_stage_3
self.assertEqual(ticket.stage_id, self.ticket_stage_2)
ticket.nonconformity_id.stage_id = self.nonconformity_stage_1
self.assertEqual(ticket.stage_id, self.ticket_stage_1)
| 45.860465 | 1,972 |
1,443 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class MgmtsystemNonconformity(models.Model):
_inherit = "mgmtsystem.nonconformity"
ticket_ids = fields.One2many(
comodel_name="helpdesk.ticket",
inverse_name="nonconformity_id",
string="Tickets",
)
ticket_count = fields.Integer(compute="_compute_ticket_count")
@api.depends("ticket_ids")
def _compute_ticket_count(self):
ticket_data = self.env["helpdesk.ticket"].read_group(
[("nonconformity_id", "in", self.ids)],
["nonconformity_id"],
["nonconformity_id"],
)
mapped_data = {
t["nonconformity_id"][0]: t["nonconformity_id_count"] for t in ticket_data
}
for item in self:
item.ticket_count = mapped_data.get(item.id, 0)
def write(self, vals):
res = super().write(vals)
if vals.get("stage_id") and not self.env.context.get("skip_stage_change"):
ticket_stage = self.env["helpdesk.ticket.stage"].search(
[("nonconformity_stage_id", "=", vals.get("stage_id"))], limit=1
)
if ticket_stage and self.ticket_ids:
self.ticket_ids.with_context(skip_stage_change=True).write(
{"stage_id": ticket_stage.id}
)
return res
| 36.025 | 1,441 |
373 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import fields, models
class HelpdeskTicketStage(models.Model):
_inherit = "helpdesk.ticket.stage"
nonconformity_stage_id = fields.Many2one(
comodel_name="mgmtsystem.nonconformity.stage",
string="Nonconformity Stage",
)
| 28.538462 | 371 |
2,500 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import _, fields, models
from odoo.exceptions import UserError
class HelpdeskTicket(models.Model):
_inherit = "helpdesk.ticket"
nonconformity_id = fields.Many2one(
comodel_name="mgmtsystem.nonconformity",
string="Nonconformity",
)
def _prepare_nonconformity_vals(self):
stage = self.stage_id.nonconformity_stage_id or self.env.ref(
"mgmtsystem_nonconformity.stage_draft"
)
vals = {
"ticket_ids": [(6, 0, self.ids)],
"name": self.name,
"partner_id": self.partner_id.id,
"stage_id": stage.id,
"user_id": self.user_id.id,
"manager_user_id": self.team_id.user_id.id or self.user_id.id,
"responsible_user_id": self.team_id.user_id.id or self.user_id.id,
"description": self.description,
}
if stage.state == "open":
vals.update({"action_comments": self.description})
elif stage.state == "done":
vals.update({"evaluation_comments": self.description})
return vals
def action_nonconformity_create(self):
if self.filtered("nonconformity_id"):
raise UserError(_("There are already linked nonconformities."))
nonconformity_model = self.env["mgmtsystem.nonconformity"].with_context(
skip_stage_change=True
)
for item in self:
item.nonconformity_id = nonconformity_model.create(
item._prepare_nonconformity_vals()
)
def action_open_nonconformity(self):
return {
"name": _("Nonconformity"),
"view_mode": "form",
"res_model": "mgmtsystem.nonconformity",
"res_id": self.nonconformity_id.id,
"type": "ir.actions.act_window",
"context": dict(self._context, create=False),
}
def write(self, vals):
res = super().write(vals)
if vals.get("stage_id") and not self.env.context.get("skip_stage_change"):
items = self.mapped("nonconformity_id")
stage = self.env["helpdesk.ticket.stage"].browse(vals.get("stage_id"))
if stage.nonconformity_stage_id and items:
items.with_context(skip_stage_change=True).write(
{"stage_id": stage.nonconformity_stage_id.id}
)
return res
| 37.848485 | 2,498 |
1,282 |
py
|
PYTHON
|
15.0
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Helpdesk Management",
"summary": """
Helpdesk""",
"version": "15.0.3.7.0",
"license": "AGPL-3",
"category": "After-Sales",
"author": "AdaptiveCity, "
"Tecnativa, "
"ForgeFlow, "
"C2i Change 2 Improve, "
"Domatix, "
"Factor Libre, "
"SDi Soluciones, "
"Odoo Community Association (OCA)",
"website": "https://github.com/OCA/helpdesk",
"depends": ["mail", "portal"],
"data": [
"data/helpdesk_data.xml",
"security/helpdesk_security.xml",
"security/ir.model.access.csv",
"views/res_partner_views.xml",
"views/res_config_settings_views.xml",
"views/helpdesk_ticket_templates.xml",
"views/helpdesk_ticket_menu.xml",
"views/helpdesk_ticket_team_views.xml",
"views/helpdesk_ticket_stage_views.xml",
"views/helpdesk_ticket_category_views.xml",
"views/helpdesk_ticket_channel_views.xml",
"views/helpdesk_ticket_tag_views.xml",
"views/helpdesk_ticket_views.xml",
"views/helpdesk_dashboard_views.xml",
],
"demo": ["demo/helpdesk_demo.xml"],
"development_status": "Beta",
"application": True,
"installable": True,
}
| 32.05 | 1,282 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.