def logbook_weeks(self): weeks = [] f = format.LangFormat(self._cr, self._uid, self._context) week_start = util.getFirstOfWeek(self.date_start) date_end = self.date_end or util.getPrevDayDate( util.getFirstOfNextWeek(util.currentDate())) while week_start <= date_end: week_str = datetime.strftime(util.strToDate(week_start), _("CW %W")) week_first = week_start week_start = util.getFirstOfNextWeek(week_start) week_end = util.getPrevDayDate(week_start) weeks.append({ "name": week_str, "date_start": week_first, "group": week_first[:7], "start": f.formatLang(week_first, date=True), "end": f.formatLang(week_end, date=True) }) weeks.sort(key=lambda v: v["date_start"], reverse=True) return weeks
def barkeeper_days(self, cr, uid, dt, context=None): range_start = util.getFirstOfMonth(dt) range_end = util.getFirstOfNextMonth(dt) cr.execute( "SELECT to_char(start_at, 'YYYY-MM-DD') FROM pos_session WHERE start_at >= %s AND start_at < %s GROUP BY 1 ORDER BY 1 DESC", (range_start, range_end)) data = [] f = format.LangFormat(cr, uid, context=context) for str_date, in cr.fetchall(): week = util.getWeek(str_date) data.append({ "name": "%s, %s" % (f.formatLang(str_date, date=True), f.getDayShortName(str_date, context=context)), "date": str_date, "group": _("Week %s") % week, "mode": "day" }) return { "title": "%s %s" % (helper.getMonth(cr, uid, dt, context), dt[:4]), "data": data, "group": True }
def _discount_calc_get(self, cr, uid, ids, field_name, arg, context=None): res = dict.fromkeys(ids) f_price = format.LangFormat(cr, uid, context=context, obj=self, f="discount_price") f_discount = format.LangFormat(cr, uid, context=context, obj=self, f="discount") for obj in self.browse(cr, uid, ids, context): val = [] if obj.discount_action: val.append("!") if obj.discount_price: if obj.discount_unit: val.append("*%s" % f_price.formatLang(obj.discount_price)) else: val.append("=%s" % f_price.formatLang(obj.discount_price)) elif obj.discount: val.append("%s%%" % f_discount.formatLang(obj.discount)) res[obj.id] = "".join(val) or None return res
def _prepare_order_line_procurement(self, cr, uid, order, line, group_id=False, context=None): vals = super(sale_order, self)._prepare_order_line_procurement(cr, uid, order, line, group_id=group_id, context=context) if order.dynbom_location_id: product = line.product_id if product: if product.dynbom: f = format.LangFormat(cr, uid, context=context, dp="Product UoS") name = vals.get("name") or "" line_names = [] for mat_line in order.order_line: if mat_line.id != line.id: uom = mat_line.product_uos or mat_line.product_uom line_names.append( "%s x %s %s" % (f.formatLang(mat_line.product_uos_qty), uom.name, mat_line.name)) if line_names: name = "%s\n\n%s\n\n" % (name, "\n\n".join(line_names)) vals["name"] = name else: vals["location_id"] = order.dynbom_location_id.id parent_loc = order.dynbom_location_id.location_id partner = parent_loc.partner_id if not partner: partner = parent_loc.company_id.partner_id vals["partner_dest_id"] = partner.id return vals
def barkeeper_months(self, cr, uid, dt, context=None): range_start = util.getFirstOfYear(dt) range_end = util.getFirstOfNextYear(dt) cr.execute( "SELECT to_char(start_at, 'YYYY-MM') FROM pos_session WHERE start_at >= %s AND start_at < %s GROUP BY 1 ORDER BY 1 DESC", (range_start, range_end)) data = [] f = format.LangFormat(cr, uid, context=context) for m, in cr.fetchall(): str_date = "%s-01" % m data.append({ "name": f.getMonthName(str_date, context), "date": str_date, "mode": "month", "next": "barkeeper_days", "nextTitle": _("Day") }) return {"title": dt[:4], "data": data}
def _prepare_cost_invoice(self, cr, uid, partner, company_id, currency_id, analytic_lines, context=None): res = super(account_analytic_line, self)._prepare_cost_invoice(cr, uid, partner, company_id, currency_id, analytic_lines, context=context) line_ids = [l.id for l in analytic_lines] account = analytic_lines[0].account_id f = format.LangFormat(cr, uid, context) cr.execute("SELECT MIN(line.date), MAX(line.date) " \ "FROM account_analytic_line as line " \ "WHERE account_id = %s " \ "AND id IN %s AND to_invoice IS NOT NULL", (account.id, tuple(line_ids))) invoice_name = None for date_from, date_to in cr.fetchall(): if date_from and date_to: invoice_name = "%s %s - %s" % ( account.name or "",f.formatLang(date_from,date=True), f.formatLang(date_to,date=True)) if not invoice_name: invoice_name = "%s %s" % (account.name or "",f.formatLang(util.currentDate(),date=True)) res["name"] = invoice_name return res
def action_create(self, cr, uid, ids, context=None): wizard = self.browse(cr, uid, ids[0], context) report_ctx = context and dict(context) or {} report_ctx["date_start"] = wizard.date_start report_ctx["date_end"] = wizard.date_end if wizard.unit == "semester": if wizard.sem_start_id.id == wizard.sem_end_id.id: report_ctx["duration_title"] = wizard.sem_start_id.name_get( )[0][1] else: report_ctx["duration_title"] = "%s - %s" % ( wizard.sem_start_id.name_get()[0][1], wizard.sem_end_id.name_get()[0][1]) elif wizard.unit == "period": if wizard.period_start_id.id == wizard.period_end_id.id: report_ctx["duration_title"] = wizard.period_start_id.name_get( )[0][1] else: report_ctx["duration_title"] = "%s - %s" % ( wizard.period_start_id.name_get()[0][1], wizard.period_end_id.name_get()[0][1]) else: f = format.LangFormat(cr, uid, context) report_ctx["duration_title"] = "%s - %s" % (f.formatLang( wizard.date_start, date=True), f.formatLang(wizard.date_end, date=True)) datas = { "ids": util.active_ids(context, "academy.trainer"), "model": "academy.trainer" } return { "type": "ir.actions.report.xml", "report_name": "trainer.reg", "datas": datas, "context": report_ctx }
def registration_post(self, stage=1, **kwargs): cr, uid, context = request.cr, request.uid, request.context public_user = request.registry["res.users"].browse( request.cr, request.uid, request.uid, context=request.context) company = public_user.company_id hidden_user = company.academy_webuser_id or public_user hidden_uid = hidden_user.id courses = [] # used obj academy_product_obj = request.registry["academy.course.product"] uom_obj = request.registry["product.uom"] location_obj = request.registry["academy.location"] student_obj = request.registry["academy.student"] partner_obj = request.registry["res.partner"] city_obj = request.registry["res.city"] reg_obj = request.registry["academy.registration"] # build selection is_student_of_loc = False parent_address = True invoice_address = False extra_info = None read_school_rules = None invoice_monthly = False invoice_per_mail = False for key, value in kwargs.items(): if key == "is_student_of_loc": is_student_of_loc = True elif key == "has_legal_age": parent_address = False elif key == "has_invoice_address": invoice_address = True elif key == "textinput_extra_info": extra_info = value elif key == "read_school_rules": read_school_rules = True elif key == "invoice_monthly": invoice_monthly = True elif key == "invoice_mail": invoice_per_mail = value == "mail" else: m = PATTERN_PRODUCT.match(key) if m: uom_id = util.getId(value) if uom_id: course_prod = academy_product_obj.browse( cr, hidden_uid, util.getId(m.group(1)), context=context) uom = uom_obj.browse(cr, hidden_uid, uom_id, context=context) courses.append((course_prod, uom)) # location location_id = util.getId(kwargs.get("location_id")) location = location_id and location_obj.browse( cr, hidden_uid, location_id, context=context) or None address = location and location.address_id location_lines = [] if address: location_lines.append(address.name) if address.street: location_lines.append(address.street) if address.street2: location_lines.append(address.street2) if address.zip: if address.city: location_lines.append("%s %s" % (address.zip, address.city)) else: location_lines.append(address.zip) # registration registration = kwargs.get("registration") lock_hash = None try: if registration: # lock lock_hash = hash("academy_registration_%s" % registration) cr.execute("SELECT pg_advisory_lock(%s)" % lock_hash) cr.commit() # search registration reg_id = reg_obj.search_id(cr, hidden_uid, [("name", "=", registration)], context=context) if reg_id: values = { "message_title": _("Registration already finished!"), "message_text": _("<p>Registration %s was done</p>") % registration } return request.website.render("website_academy.message", values, context=context) # handle stage if stage == 2: # finish registration warnings = [] messages = [] # def create_address(obj, fields, data, name): """ get address or create new :return (id,Name) """ # search address address_id = obj.search_id( cr, hidden_uid, [("name", "=", data.get("name")), ("email", "=", data.get("email"))]) if address_id: cur_data = obj.read(cr, hidden_uid, address_id, fields, context=context) changes = [] fields = obj.fields_get(cr, hidden_uid, allfields=fields, context=context) for key, value in cur_data.items(): if key == "id": continue value1 = value or "" value2 = data.get(key) or "" # get name if it is a many2one field if isinstance(value1, tuple): value1 = value1[1] if isinstance(value2, tuple): value2 = value2[1] if value1 != value2: changes.append( _("Value of field '%s' is '%s' but customer typed '%s'" ) % (fields[key]["string"], value1, value2)) if changes: warnings.append("<p><b>%s</b></p>" % name) for change in changes: warnings.append("<p>%s</p>" % change) warnings.append("<p></p>") else: # convert tuple to id for key, value in data.items(): if isinstance(value, tuple): data[key] = value[0] # create new address address_id = obj.create(cr, hidden_uid, data, context=context) if address_id: return obj.name_get(cr, hidden_uid, [address_id], context=context)[0] return None def get_address(prefix): """ parse address data """ # simple get def get(name): arg = kwargs.get("%s_%s" % (prefix, name)) return arg and arg.strip() or "" firstname = get("firstname") lastname = get("lastname") email = get("email") if not firstname or not lastname or not email: return None name = "%s %s" % (lastname, firstname) city = get("city") zip_code = get("zip") res = { "name": name, "email": email, "street": get("street"), "zip": zip_code, "city": city } nationality = get("nationality") if nationality: res["nationality"] = nationality birthday_dt, birthday = util.tryParseDate(get("birthday")) if birthday_dt: res["birthday"] = util.dateToStr(birthday_dt) phone = get("phone") if phone: res["phone"] = phone city_values = city_obj.search_read(cr, hidden_uid, [("code", "=", zip)], ["name", "state_id"], context=context) for city_val in city_values: if re.sub("[^A-Za-z]", "", city) == re.sub("[^A-Za-z]", "", city_val["name"]): res["state_id"] = city_val["state_id"] res["city"] = city_val["name"] break return res if not courses: raise osv.except_osv(_("Error"), _("No courses selected")) student_values = get_address("form_student") if not student_values: raise osv.except_osv(_("Error"), _("No student address passed")) if parent_address: parent_values = get_address("form_parent") if not parent_values: raise osv.except_osv(_("Error"), _("No parent address passed")) student_values["parent_id"] = create_address( partner_obj, [ "name", "email", "street", "zip", "city", "phone", "birthday" ], parent_values, _("Parent")) invoice_address_id = None if invoice_address: invoice_values = get_address("form_invoice") if not invoice_values: raise osv.except_osv(_("Error"), _("No invoice address passed")) invoice_address_id = create_address( partner_obj, ["name", "email", "street", "zip", "city", "phone"], invoice_values, _("Invoice Address"))[0] # create student address student = create_address(student_obj, [ "name", "email", "street", "zip", "city", "phone", "nationality", "birthday", "parent_id" ], student_values, _("Student")) # create courses for course in courses: values = { "course_prod_id": course[0].id, "uom_id": course[1].id, "student_id": student[0], "location_id": location_id, "student_of_loc": is_student_of_loc, "note": extra_info, "read_school_rules": read_school_rules, "invoice_monthly": invoice_monthly, "invoice_per_mail": invoice_per_mail } # set invoice address id if invoice_address_id: values["invoice_address_id"] = invoice_address_id # set registration number if registration: values["name"] = registration registration = None # create, register and commit reg_id = reg_obj.create(cr, hidden_uid, values, context=context) reg_name = reg_obj.read(cr, hidden_uid, reg_id, ["name"], context=context)["name"] reg_obj.do_register(cr, hidden_uid, [reg_id], context=context, check=True) cr.commit() # create status message messages.append( _("<p>Registration %s was created.</p>") % reg_name) # add info if something is to add if warnings: warnings = "\n".join(warnings) reg_obj.message_post(cr, hidden_uid, reg_id, body=warnings, context=context) values = { "message_title": _("Registration finished!"), "message_text": "\n".join(messages) } return request.website.render("website_academy.message", values, context=context) else: # check for fee f = format.LangFormat(cr, uid, context=context) mail_fee_option = "" fee_obj = request.registry["academy.fee"] fee_values = fee_obj.search_read(cr, SUPERUSER_ID, [("per_mail", "=", True)], ["list_price"], context=context) if fee_values: price = fee_values[0]["list_price"] mail_fee_option = _( "Invoice per mail with additional fee of %s %s") % ( f.formatLang(price), company.currency_id.symbol) # begin registration values = { "courses": courses, "location": location, "location_lines": location_lines, "is_student_of_loc": is_student_of_loc, "invoice_per_mail": invoice_per_mail, "location_id": location_id, "mail_fee_option": mail_fee_option, "registration": reg_obj._next_sequence(cr, hidden_uid, context) } return request.website.render("website_academy.registration", values) finally: # unlock if lock_hash: cr.execute("SELECT pg_advisory_unlock(%s)" % lock_hash)
def _recurring_task_create(self, cr, uid, ids, automatic=False, context=None): if context is None: context = {} task_ids = [] current_date = util.currentDate() if ids: contract_ids = ids else: contract_ids = self.search(cr, uid, [("use_tasks","=",True), ("recurring_task_next","<=", current_date), ("state","=", "open"), ("recurring_task","=", True), ("type", "=", "contract")]) if contract_ids: task_obj = self.pool["project.task"] recurring_task_obj = self.pool["account.analytic.recurring.task"] project_obj = self.pool["project.project"] f = format.LangFormat(cr, uid, context) cr.execute("SELECT company_id, array_agg(id) as ids FROM account_analytic_account WHERE id IN %s GROUP BY company_id", (tuple(contract_ids),)) for company_id, ids in cr.fetchall(): context_contract = dict(context, company_id=company_id, force_company=company_id) for contract in self.browse(cr, uid, ids, context=context_contract): project_ids = project_obj.search(cr, uid, [("analytic_account_id","=",contract.id)], context=context_contract) if not project_ids: raise Warning(_("No Project for generating tasks of contract %s found") % contract.name) project = project_obj.browse(cr, uid, project_ids[0], context=context_contract) try: # get interval interval = contract.recurring_task_interval rule = contract.recurring_rule_type next_date = contract.recurring_task_next or current_date if contract.recurring_task_rule == "daily": # daily dt_interval = relativedelta(days=interval) interval_name = f.formatLang(next_date, date=True) elif contract.recurring_task_rule == "weekly": # weekly dt_interval = relativedelta(weeks=interval) interval_name = _("%s WE%s") % (util.getYearStr(next_date), util.getWeek(next_date)) elif contract.recurring_task_rule == "monthly": # monthly dt_interval = relativedelta(months=interval) interval_name = helper.getMonthYear(cr, uid, next_date, context=context) else: # yearly interval_name = util.getYearStr(next_date) dt_interval = relativedelta(years=interval) # next date next_date = util.dateToStr(util.strToDate(next_date) + dt_interval) # execute task processed_tasks = 0 finished_tasks = 0 for recurring_task in contract.recurring_task_ids: task_values = self._recurring_task_prepare(cr, uid, project, recurring_task, interval_name, next_date, context=context_contract) if task_values: processed_tasks += 1 # execute task if it is not finished task_count = recurring_task.count if not recurring_task.repeat or task_count < recurring_task.repeat: task_count = recurring_task.count + 1 task_ids.append(task_obj.create(cr, uid, task_values, context=context_contract)) recurring_task_obj.write(cr, uid, [recurring_task.id], {"count": task_count}, context=context_contract) # check if task is finished if recurring_task.repeat and task_count >= recurring_task.repeat: finished_tasks += 1 # check if all tasks are finished if finished_tasks and finished_tasks == processed_tasks: values["recurring_task"] = False # update contract values = {"recurring_task_next": next_date} self.write(cr, uid, [contract.id], values, context=context) # commit if automatic if automatic: cr.commit() except Exception: # log error if automatic if automatic: cr.rollback() _logger.exception("Fail to create recurring task for contract %s [%s]", (contract.name, contract.code)) else: raise return task_ids
def _prepare_cost_invoice_line(self, cr, uid, invoice_id, product_id, uom, user_id, factor_id, account, analytic_lines, journal_type, data, context=None): product_obj = self.pool['product.product'] f = format.LangFormat(cr, uid, context) uom_context = dict(context or {}, uom=uom) total_price = sum(l.amount for l in analytic_lines) total_qty = sum(l.unit_amount for l in analytic_lines) if data.get('product'): # force product, use its public price if isinstance(data['product'], (tuple, list)): product_id = data['product'][0] else: product_id = data['product'] unit_price = self._get_invoice_price(cr, uid, account, product_id, user_id, total_qty, uom_context) elif journal_type == 'general' and product_id: # timesheets, use sale price unit_price = self._get_invoice_price(cr, uid, account, product_id, user_id, total_qty, uom_context) else: # expenses, using price from amount field unit_price = total_price*-1.0 / total_qty factor = self.pool['hr_timesheet_invoice.factor'].browse(cr, uid, factor_id, context=uom_context) factor_name = factor.customer_name or '' curr_invoice_line = { 'price_unit': unit_price, 'quantity': total_qty, 'product_id': product_id, 'discount': factor.factor, 'invoice_id': invoice_id, 'name': factor_name, 'uos_id': uom, 'account_analytic_id': account.id, } if product_id: product = product_obj.browse(cr, uid, product_id, context=uom_context) factor_name = product_obj.name_get(cr, uid, [product_id], context=uom_context)[0][1] if factor.customer_name: factor_name += ' - ' + factor.customer_name general_account = product.property_account_income or product.categ_id.property_account_income_categ if not general_account: raise osv.except_osv(_('Error!'), _("Configuration Error!") + '\n' + _("Please define income account for product '%s'.") % product.name) taxes = product.taxes_id or general_account.tax_ids tax = self.pool['account.fiscal.position'].map_tax(cr, uid, account.partner_id.property_account_position, taxes) curr_invoice_line.update({ 'invoice_line_tax_id': [(6, 0, tax)], 'name': factor_name, 'invoice_line_tax_id': [(6, 0, tax)], 'account_id': general_account.id, }) note = [] for line in analytic_lines: # set invoice_line_note details = [] if data.get('date', False): details.append(f.formatLang(line['date'],date=True)) if data.get('time', False): line_time = f.formatLang(line.unit_amount,float_time=True) if line['product_uom_id']: details.append("%s %s" % (line_time, line.product_uom_id.name)) else: details.append("%s" % (line_time, )) if data.get('name', False): details.append(line['name']) if details: note.append(u' - '.join(map(lambda x: unicode(x) or '', details))) if note: curr_invoice_line['name'] += "\n" + ("\n".join(map(lambda x: unicode(x) or '', note))) return curr_invoice_line
def logbook_week(self, date_start=None): if not date_start: date_start = util.currentDate() f = format.LangFormat(self._cr, self._uid, self._context) week_start = util.getFirstOfWeek(date_start) week_next = util.getFirstOfNextWeek(date_start) week_str = datetime.strftime(util.strToDate(week_start), _("CW %W")) week_day = week_start week_end = week_day days = [] log_obj = self.env["farm.chicken.log"] sum_loss = 0 first_weight = 0.0 valid_count = 0 fill_count = 0 day_count = 0 chicken_count = 0 avg_data = {} def getAvg(name, calc=True): data = avg_data.get(name, None) if data is None: data = {"val": [], "avg": 0.0} avg_data[name] = data if calc: val = data["val"][:7] val_len = len(val) if val_len: data["avg"] = sum(val) / val_len return data def addAvg(name, val): if val: data = getAvg(name, calc=False) data["val"].insert(0, val) return val # get 14 logs for average calc logByDay = {} logs = log_obj.search([("logbook_id", "=", self.id), ("day", "<", week_next)], limit=14, order="day desc") if logs: # set new start week_day_avg = logs[-1].day if week_day_avg < week_day: week_day = week_day_avg # assign log for log in logs: logByDay[log.day] = log chicken_age_weeks = 0 while week_day < week_next: week_end = week_day loss = 0 loss_fix = False loss_fix_amount = 0 loss_amount = 0 eggs_performance = 0.0 weight = 0 eggs_total = 0 eggs_broken = 0 eggs_dirty = 0 eggs_weight = 0 eggs_machine = 0 chicken_age = 0 feed = 0 water = 0 valid = False filled = False note = "" log = logByDay.get(week_day) if log: loss = log.loss loss_amount = log.loss_amount or 0 loss_fix = log.loss_fix loss_fix_amount = log.loss_fix_amount eggs_total = addAvg("eggs_total", log.eggs_total) eggs_broken = addAvg("eggs_broken", log.eggs_broken) eggs_dirty = addAvg("eggs_dirty", log.eggs_dirty) eggs_weight = addAvg("eggs_weight", log.eggs_weight) eggs_machine = addAvg("eggs_machine", log.eggs_machine) eggs_performance = addAvg("eggs_performance", log.eggs_performance) feed = addAvg("feed", log.feed) water = addAvg("water", log.water) weight = log.weight if weight and not first_weight: first_weight = weight chicken_count = log.chicken_count note = log.note or note chicken_age_weeks = log.chicken_age_weeks chicken_age = log.chicken_age valid = log.state != "draft" filled = True if filled: day_count += 1 sum_loss += loss_amount # add day only if within week if week_day >= week_start: if filled: fill_count += 1 if valid: valid_count += 1 days.append({ "name": format_date(util.strToDate(week_day), "E d.M.y", locale=self._context.get("lang") or tools.config.defaultLang), "day": week_day, "loss": loss, "loss_fix": loss_fix, "loss_fix_amount": loss_fix_amount, "eggs_total": eggs_total, "eggs_broken": eggs_broken, "eggs_dirty": eggs_dirty, "eggs_weight": eggs_weight, "eggs_machine": eggs_machine, "weight": weight, "note": note, "valid": valid, "filled": filled, "chicken_age_weeks": chicken_age_weeks, "overview": [{ "name": _("Eggs Total"), "value": "%s" % eggs_total }, { "name": _("Eggs Machine"), "value": "%s" % eggs_machine }, { "name": _("Broken Eggs"), "value": "%s" % eggs_broken }, { "name": _("Dirty Eggs"), "value": "%s" % eggs_dirty }, { "name": _("Eggs Weight"), "value": "%s g" % f.formatLang(eggs_weight) }, { "name": _("Egg Performance"), "value": "%s %%" % f.formatLang(eggs_performance) }, { "name": _("Loss"), "value": "%s" % loss_amount }, { "name": _("Chicken Count"), "value": "%s" % chicken_count }, { "name": _("Chicken Weight"), "value": "%s kg" % f.formatLang(weight) }, { "name": _("Day Age"), "value": "%s" % chicken_age }, { "name": _("Feed"), "value": "%s kg" % f.formatLang(feed, digits=0) }, { "name": _("Water"), "value": "%s l" % f.formatLang(water) }] }) week_day = util.getNextDayDate(week_day) days_len = len(days) return { "name": "%s %s" % (self.name, week_str), "week": week_str, "date": week_start, "start": f.formatLang(week_start, date=True), "end": f.formatLang(week_end, date=True), "filled": days_len == fill_count, "validated": days_len == valid_count, "days": days, "overview": [{ "name": _("Eggs"), "value": "%s" % f.formatLang(getAvg("eggs_total")["avg"]) }, { "name": _("Eggs Machine"), "value": "%s" % f.formatLang(getAvg("eggs_machine")["avg"]) }, { "name": _("Broken Eggs"), "value": "%s" % f.formatLang(getAvg("eggs_broken")["avg"]) }, { "name": _("Dirty Eggs"), "value": "%s" % f.formatLang(getAvg("eggs_dirty")["avg"]) }, { "name": _("Eggs Weight"), "value": "%s g" % f.formatLang(getAvg("eggs_weight")["avg"]) }, { "name": _("Egg Performance"), "value": "%s %%" % f.formatLang(getAvg("eggs_performance")["avg"]) }, { "name": _("Loss"), "value": "%s" % sum_loss, }, { "name": _("Chicken Count"), "value": "%s" % chicken_count }, { "name": _("Chicken Weight"), "value": "%s kg" % f.formatLang(first_weight) }, { "name": _("Week Age"), "value": "%s" % chicken_age_weeks }, { "name": _("Feed"), "value": "%s kg" % f.formatLang(getAvg("feed")["avg"], digits=0) }, { "name": _("Water"), "value": "%s l" % f.formatLang(getAvg("water")["avg"]) }] }
def fpos_ga_order_create(self, cr, uid, partner_id, order_ids, defaults=None, context=None): jdoc_obj = self.pool["jdoc.jdoc"] order_obj = self.pool["pos.order"] fpos_line_obj = self.pool["fpos.order.line"] fpos_order_obj = self.pool["fpos.order"] data_obj = self.pool["ir.model.data"] product_balance_id = data_obj.xmlid_to_res_id( cr, uid, "fpos.product_fpos_balance", raise_if_not_found=True) f = format.LangFormat(cr, uid, context=context) lines = [] filtered_order_ids = [] partner_id = None first = True order_ids = order_obj.search(cr, uid, [("id", "in", order_ids)], context=context) for order in order_obj.browse(cr, SUPERUSER_ID, order_ids, context=context): fpos_order = order.fpos_order_id if not fpos_order: continue if fpos_order.partner_id: partner_id = fpos_order.partner_id.id if partner_id != partner_id: continue filtered_order_ids.append(order.id) lines.append({ "name": " ".join([ f.formatLang(fpos_order.date, date_time=True), order.name ]), "notice": order.pos_reference, "qty": 1, "price": fpos_order.amount_total, "subtotal_incl": fpos_order.amount_total, "subtotal": fpos_order.amount_total, "tag": "s", "flags": first and "1b" or "1bl" # main section }) first = False line_values = None for fpos_line in fpos_order.line_ids: if fpos_line.tag and not fpos_line.tag in ("i", "o"): continue line_values = fpos_line_obj.copy_data(cr, uid, fpos_line.id, context=context) # replace product with none line_values["product_id"] = product_balance_id # sub section and payment flags = line_values.get("flags") or "" if flags.find("2") < 0: flags += "2" if flags.find("x") < 0: flags += "x" # correct negative idx_minus = flags.find("-") if idx_minus < 0 and fpos_line.subtotal_incl < 0: flags += "-" elif idx_minus >= 0 and fpos_line.subtotal_incl > 0: flags = flags.replace("-", "") # set flags line_values["flags"] = flags # add lines.append(line_values) # set values for order order_values = defaults and dict(defaults) or {} order_values["line_ids"] = [(0, 0, l) for l in lines] order_values["fpos_user_id"] = uid if not "user_id" in order_values: order_values["user_id"] = uid if not "date" in order_values: order_values["date"] = util.currentDateTime() if not "ref" in order_values: order_values["ref"] = _("Group Invoice") if partner_id and not "partner_id" in order_values: order_values["partner_id"] = partner_id # create order fpos_ga_order_id = fpos_order_obj.create(cr, uid, order_values, context=context) # update order group order_obj.write(cr, uid, filtered_order_ids, {"fpos_group_id": fpos_ga_order_id}, context=context) res = jdoc_obj.jdoc_by_id(cr, uid, "fpos.order", fpos_ga_order_id, options={"empty_values": False}, context=context) return res
def _prepare_order_line_invoice_line(self, cr, uid, line, account_id=False, context=None): # if contract, no invoice if line.is_contract: return False res = super(sale_order_line, self)._prepare_order_line_invoice_line(cr, uid, line, account_id, context) product = line.product_id if product and product.type == "service" and product.billed_at_cost: task_obj = self.pool["project.task"] task_ids = task_obj.search(cr, SUPERUSER_ID, [("sale_line_id","=",line.id)]) f = format.LangFormat(cr, uid, context=context) task_set = set() work_info = [] effective_hours = 0.0 # add task and childs def add_task(task): # check if task already processed if task.id in task_set: return 0.0 hours = 0.0 # check work for work in task.work_ids: if work.hours: # round to quarter and add work_minutes = round(work.hours * 60) work_minutes_rest = work_minutes % 15 if work_minutes_rest: work_minutes = work_minutes + (15 - work_minutes_rest) task_hours = float(work_minutes) / 60.0 hours+=task_hours work_line = [] # append date if work.date: work_line.append(f.formatLang(util.timeToDateStr(work.date), date=True)) # append time work_line.append(_("%s Hour(s)") % f.formatLang(task_hours, float_time=True)) # append name if work.name: work_line.append(work.name) work_info.append(" - ".join(work_line)) # add childs task_set.add(task.id) for child_task in task.child_ids: hours += add_task(child_task) return hours # build task set for task in task_obj.browse(cr, SUPERUSER_ID, task_ids, context=context): effective_hours += add_task(task) # get quantity res["quantity"] = effective_hours # set new work info if work_info: res["name"] = "%s\n%s" % (res["name"], "\n".join(work_info)) return res