def testModelHref(self): "Test model href" pool = Pool() UrlObject = pool.get('test.urlobject') db_name = Transaction().database.name self.assertEqual(UrlObject.__href__, '%s/#%s/model/test.urlobject' % ( http_host(), urllib.parse.quote(db_name))) self.assertEqual(UrlObject(1).__href__, '%s/#%s/model/test.urlobject/1' % ( http_host(), urllib.parse.quote(db_name)))
def testWizardHref(self): "Test wizard href" pool = Pool() UrlWizard = pool.get('test.test_wizard', type='wizard') db_name = Transaction().database.name self.assertEqual(UrlWizard.__href__, '%s/#%s/wizard/test.test_wizard' % ( http_host(), urllib.parse.quote(db_name)))
def get_context(cls, records, data): pool = Pool() Lang = pool.get('ir.lang') context = super(EmailResetPassword, cls).get_context(records, data) lang = Lang.get() context['host'] = host() context['http_host'] = http_host() context['database'] = Transaction().database.name context['expire'] = lang.strftime(records[0].password_reset_expire, format=lang.date + ' %H:%M:%S') return context
def get_context(cls, records, header, data): context = super().get_context(records, header, data) context['host'] = host() context['http_host'] = http_host() context['database'] = Transaction().database.name expire_delay = (records[0].password_reset_expire - datetime.datetime.now()) # Use a precision of minutes expire_delay = datetime.timedelta(days=expire_delay.days, minutes=round(expire_delay.seconds / 60)) context['expire_delay'] = expire_delay return context
def prepare(cls, data): pool = Pool() Template = pool.get('product.template') Product = pool.get('product.product') Move = pool.get('stock.move') Location = pool.get('stock.location') Company = pool.get('company.company') try: Production = pool.get('production') except: Production = None try: Lot = pool.get('stock.lot') except: Lot = None move = Move.__table__() cursor = Transaction().connection.cursor() t_context = Transaction().context company_id = t_context.get('company') from_date = data.get('from_date') or datetime.min.date() to_date = data.get('to_date') or datetime.max.date() warehouse = Location(data.get('warehouse')) parameters = {} parameters['from_date'] = from_date parameters['to_date'] = to_date parameters['warehouse'] = warehouse.rec_name parameters['show_date'] = True if data.get('from_date') else False parameters['production'] = True if Production else False parameters['lot'] = True if Lot else False parameters['base_url'] = '%s/#%s' % (http_host(), Transaction().database.name) parameters['company'] = DualRecord(Company(company_id)) # Locations locations = [ l.id for l in Location.search([('parent', 'child_of', [warehouse.id])]) ] location_suppliers = [ l.id for l in Location.search([('type', '=', 'supplier')]) ] location_customers = [ l.id for l in Location.search([('type', '=', 'customer')]) ] location_lost_founds = [ l.id for l in Location.search([('type', '=', 'lost_found')]) ] if Production: location_productions = [ l.id for l in Location.search([('type', '=', 'production')]) ] keys = () if data.get('model') == 'product.template': grouping = ('product', ) for template in Template.browse(data['ids']): for product in template.products: keys += ((product, None), ) elif data.get('model') == 'product.product': grouping = ('product', ) for product in Product.browse(data['ids']): keys += ((product, None), ) elif data.get('model') == 'stock.lot': grouping = ('product', 'lot') Lot = pool.get('stock.lot') for lot in Lot.browse(data['ids']): keys += ((lot.product, lot), ) def compute_quantites(sql_where): Uom = Pool().get('product.uom') query = move.select(move.id.as_('move_id'), where=sql_where, order_by=move.effective_date.desc) cursor.execute(*query) move_ids = [m[0] for m in cursor.fetchall()] moves = Move.browse(move_ids) total = sum([ Uom.compute_qty(m.uom, m.quantity, m.product.default_uom, True) for m in moves ]) moves = [DualRecord(m) for m in moves] return total, moves records = [] for key in keys: product = key[0] lot = key[1] # Initial stock context = {} context['stock_date_end'] = from_date with Transaction().set_context(context): pbl = Product.products_by_location( [warehouse.id], with_childs=True, grouping_filter=([product.id], ), grouping=grouping) key = ((warehouse.id, product.id, lot.id) if lot else (warehouse.id, product.id)) initial_stock = pbl.get(key, 0) sql_common_where = ((move.product == product.id) & (move.effective_date >= from_date) & (move.effective_date <= to_date) & (move.state == 'done') & (move.company == company_id)) if lot: sql_common_where &= (move.lot == lot.id) # supplier_incommings from_location = supplier sql_where = (sql_common_where & (move.from_location.in_(location_suppliers)) & (move.to_location.in_(locations))) supplier_incommings_total, supplier_incommings = compute_quantites( sql_where) # supplier_returns: to_location = supplier sql_where = (sql_common_where & (move.to_location.in_(location_suppliers)) & (move.from_location.in_(locations))) supplier_returns_total, supplier_returns = compute_quantites( sql_where) # customer_outgoing: to_location = customer sql_where = (sql_common_where & (move.to_location.in_(location_customers)) & (move.from_location.in_(locations))) customer_outgoings_total, customer_outgoings = compute_quantites( sql_where) # customer_return: from_location = customer sql_where = (sql_common_where & (move.from_location.in_(location_customers)) & (move.to_location.in_(locations))) customer_returns_total, customer_returns = compute_quantites( sql_where) production_outs_total = 0 production_ins_total = 0 if Production: # production_outs: to_location = production sql_where = (sql_common_where & (move.from_location.in_(location_productions)) & (move.to_location.in_(locations))) production_outs_total, production_outs = compute_quantites( sql_where) # production_ins: from_location = production sql_where = (sql_common_where & (move.to_location.in_(location_productions)) & (move.from_location.in_(locations))) production_ins_total, production_ins = compute_quantites( sql_where) # inventory sql_where = (sql_common_where & (move.from_location.in_(location_lost_founds)) & (move.to_location.in_(locations))) lost_found_from_total, lost_found_from = compute_quantites( sql_where) sql_where = (sql_common_where & (move.to_location.in_(location_lost_founds)) & (move.from_location.in_(locations))) lost_found_to_total, lost_found_to = compute_quantites(sql_where) # Entries from outside warehouse locations_in_out = (locations + location_lost_founds + location_suppliers + location_customers) if Production: locations_in_out += location_productions sql_where = (sql_common_where & (~move.from_location.in_(locations_in_out)) & (move.to_location.in_(locations))) in_to_total, in_to = compute_quantites(sql_where) # Outputs from our warehouse sql_where = (sql_common_where & (move.from_location.in_(locations)) & (~move.to_location.in_(locations_in_out))) out_to_total, out_to = compute_quantites(sql_where) records.append({ 'product': DualRecord(product), 'lot': DualRecord(lot), 'initial_stock': initial_stock, 'supplier_incommings_total': supplier_incommings_total, 'supplier_incommings': supplier_incommings, 'supplier_returns_total': (-supplier_returns_total if supplier_returns_total else 0), 'supplier_returns': supplier_returns, 'customer_outgoings_total': (-customer_outgoings_total if customer_outgoings_total else 0), 'customer_outgoings': customer_outgoings, 'customer_returns_total': customer_returns_total, 'customer_returns': customer_returns, 'production_outs_total': (production_outs_total if Production else 0), 'production_outs': production_outs if Production else 0, 'production_ins_total': (-production_ins_total if Production else 0), 'production_ins': production_ins if Production else 0, 'lost_found_total': lost_found_from_total - lost_found_to_total, 'lost_found_from_total': lost_found_from_total, 'lost_found_from': lost_found_from, 'lost_found_to_total': (-lost_found_to_total if lost_found_to_total else 0), 'lost_found_to': lost_found_to, 'in_to_total': in_to_total if in_to_total else 0, 'in_to': in_to, 'out_to_total': -out_to_total if out_to_total else 0, 'out_to': out_to, 'total': (initial_stock + supplier_incommings_total + (-supplier_returns_total) + (-customer_outgoings_total) + customer_returns_total + production_outs_total + (-production_ins_total) + (lost_found_from_total - lost_found_to_total) + in_to_total + (-out_to_total)), }) return records, parameters
import logging import string from urllib.parse import quote, urljoin from sql.aggregate import Count from trytond.config import config from trytond.model import ModelSQL, ModelView, fields from trytond.pool import Pool from trytond.tools import grouped_slice, reduce_ids from trytond.transaction import Transaction from trytond.url import http_host from trytond.wsgi import Base64Converter ALPHABET = string.digits + string.ascii_lowercase URL_BASE = config.get('web', 'shortener_base', default=http_host()) logger = logging.getLogger(__name__) class ShortenedURL(ModelSQL, ModelView): "Short URL" __name__ = 'web.shortened_url' shortened_url = fields.Function(fields.Char("Shortened URL"), 'get_url') redirect_url = fields.Char("Redirect URL", readonly=True, required=True) record = fields.Reference("Record", selection='get_models', readonly=True) method = fields.Selection('get_methods', "Method", readonly=True) count = fields.Function(fields.Integer("Click Count"), 'get_count') @classmethod def get_url(cls, shortened_urls, name):
from trytond.pool import Pool from trytond.pyson import Eval from trytond.report import Report, get_email from trytond.sendmail import SMTPDataManager, sendmail_transactional from trytond.tools import grouped_slice from trytond.tools.email_ import set_from_header from trytond.transaction import Transaction from trytond.url import http_host from trytond.wizard import Button, StateTransition, StateView, Wizard from .exceptions import TemplateError if not config.get('html', 'plugins-marketing.email.message-content'): config.set('html', 'plugins-marketing.email.message-content', 'fullpage') URL_BASE = config.get('marketing', 'email_base', default=http_host()) URL_OPEN = urljoin(URL_BASE, '/m/empty.gif') def _formataddr(name, email): if name: name = str(Header(name, 'utf-8')) return formataddr((name, email)) def _add_params(url, **params): parts = urlsplit(url) query = parse_qsl(parts.query) for key, value in sorted(params.items()): query.append((key, value)) parts = list(parts)
def prepare(cls, data): pool = Pool() Product = pool.get('product.product') Company = pool.get('company.company') Production = pool.get('production') try: Lot = pool.get('stock.lot') except: Lot = None t_context = Transaction().context company_id = t_context.get('company') from_date = data.get('from_date') or datetime.min.date() to_date = data.get('to_date') or datetime.max.date() requested_product = Product(data['product']) direction = data['direction'] lot = Lot(data['lot']) if data.get('lot') else None parameters = {} parameters['direction'] = direction parameters['from_date'] = from_date parameters['to_date'] = to_date parameters['show_date'] = bool(data.get('from_date')) parameters['requested_product'] = requested_product parameters['lot'] = Lot(data['lot']) if data.get('lot') else None parameters['base_url'] = '%s/#%s' % (http_host(), Transaction().database.name) parameters['company'] = Company(company_id) records = OrderedDict() if direction == 'backward': domain = [ ('outputs.product', '=', requested_product), ('outputs.effective_date', '>=', from_date), ('outputs.effective_date', '<=', to_date), ('outputs.state', '=', 'done'), ('company', '=', company_id), ] if lot: domain += [('outputs.lot', '=', lot)] else: domain = [ ('inputs.product', '=', requested_product), ('inputs.effective_date', '>=', from_date), ('inputs.effective_date', '<=', to_date), ('inputs.state', '=', 'done'), ('company', '=', company_id), ] if lot: domain += [('inputs.lot', '=', lot)] productions = Production.search(domain) records = {} for production in productions: res = production.mass_balance_report_data(requested_product, direction, lot) for key, values in res.items(): if not records.get(key): records.setdefault(key, {}) for k, v in values.items(): if k.endswith('_uom'): records[key][k] = v elif k in records[key]: records[key][k] += v else: records[key][k] = v return records, parameters