[IMP] Cambios varios

point_of_payment/__manifest__.py

@@ -29,3 +29,8 @@
     "installable": True,
     "application": True,
 }
+# """- Agregar users_ids en los config y regas de acceso a las seccione y cajas
+# - grupo de unica session de caja
+# - Maxima diferencia de caja en la configuracion y generar asiento de  diferencia
+# - las transferencias internas pueden elegir caja destino y en la caja destino cuando habro una session importo esas trasnferecias
+# """

point_of_payment/models/account_payment.py

@@ -15,13 +15,55 @@ class AccountPayment(models.Model):
     )
     pop_session_id = fields.Many2one('pop.session',
         string='Session',
-        #ondelete='Restrict',
+        compute="_compute_pop_session_id",
+        readonly=True,
+        store=True
     )
     pop_id = fields.Many2one('pop.config',
         string='POP config',
-        #ondelete='Restrict',
         related='pop_session_id.pop_id'
     )
+    dest_pop_id = fields.Many2one('pop.config',
+        string='Destination POP config',
+    )
+
+    def _compute_pop_session_id(self):
+        for rec in self:
+            session_ids = self.env['pop.session'].search([
+                ('user_ids', '=', self.env.uid),
+                ('state', '=', 'opened')
+            ])
+            if len(session_ids) == 1:
+                rec.pop_session_id = session_ids.id
+            else:
+                rec.pop_session_id = False
+
+    def _update_pop_session_id(self):
+        for rec in self.filtered(lambda s: s.pop_session_id and s.state=='draft'):
+            session_ids = self.env['pop.session'].search([
+                ('user_ids', '=', self.env.uid),
+                ('state', '=', 'opened'),
+                ('pop_id', '=', rec.pop_session_id.pop_id.id)
+            ])
+            if len(session_ids) == 1:
+                rec.pop_session_id = session_ids.id
+            else:
+                rec.pop_session_id = False
+
+    @api.constrains('journal_id', 'currency_id')
+    def check_journal_currency(self):
+        for payment in self:
+            if payment.currency_id != payment.journal_id.currency_id:
+                raise ValidationError(
+                    _('The currency of the journal must be the of the payment.'))
+
+    def action_receive_internal_transaction(self):
+        pop_ids = self.env['pop.session'].search([
+            ('user_ids', '=', self.env.uid),
+            ('state', '=', 'opened')
+        ]).mapped('pop_id')
+        for rec in self.filtered(lambda p: p.dest_pop_id == pop_ids and p.dest_pop_session_id == False):
+            rec.dest_pop_session_id = rec.dest_pop_id.current_session_id.id
 
     @api.depends('payment_type', 'company_id')
     def _compute_available_pop_session_ids(self):
@@ -35,12 +77,14 @@ def _compute_available_pop_session_ids(self):
     def action_post(self):
         require_session = self.env.user.has_group('point_of_payment.require_pop_session')
         for rec in self:
+            if  self.pop_session_id.state != 'opened':
+                raise UserError(_('Open payment session is required'))
+
             if not rec.pop_session_id or rec.pop_session_id not in rec.available_pop_session_ids:
-                session_id = rec.available_pop_session_ids[0]
-                if require_session and not session_id:
+                if require_session and not rec.available_pop_session_ids:
                     raise UserError(_('Open payment session is required for your user'))
+                rec.pop_session_id = rec.available_pop_session_ids.id  if rec.available_pop_session_ids else False
 
-                rec.pop_session_id = session_id.id  if session_id else False
         super().action_post()
 
     def action_cancel(self):
@@ -76,3 +120,40 @@ def _compute_available_journal_ids(self):
                     )
         else:
             super()._compute_available_journal_ids()
+
+
+    def _create_paired_internal_transfer_payment(self):
+
+        pop_transfer =  self.filtered('dest_pop_id')
+        super(AccountPayment, self - pop_transfer)._create_paired_internal_transfer_payment()
+
+        for payment in pop_transfer:
+
+            paired_payment = payment.copy({
+                'journal_id': payment.journal_id.id,
+                'destination_journal_id': payment.journal_id.id,
+                'payment_type': payment.payment_type == 'outbound' and 'inbound' or 'outbound',
+                'move_id': None,
+                'ref': payment.ref,
+                'paired_internal_transfer_payment_id': payment.id,
+                'date': payment.date,
+            })
+            paired_payment.move_id._post(soft=False)
+            payment.paired_internal_transfer_payment_id = paired_payment
+
+            body = _(
+                "This payment has been created from %s",
+                payment._get_html_link(),
+            )
+            paired_payment.message_post(body=body)
+            body = _(
+                "A second payment has been created: %s",
+                paired_payment._get_html_link(),
+            )
+            payment.message_post(body=body)
+
+            lines = (payment.move_id.line_ids + paired_payment.move_id.line_ids).filtered(
+                lambda l: l.account_id == payment.destination_account_id and not l.reconciled)
+            lines.reconcile()
+
+

point_of_payment/models/pop_config.py

@@ -32,6 +32,13 @@ class PopConfig(models.Model):
         domain=[('type', 'in', ['bank', 'cash'])],
         check_company=True
     )
+    allowed_res_users_ids = fields.Many2many(
+        'res.users',
+        relation= 'pos_config_users_rel',
+        column1= 'config_id',
+        column2= 'user_id',
+    )
+
     cash_control_journal_ids = fields.Many2many('account.journal', string='cash control journal')
     session_ids = fields.One2many('pop.session', 'pop_id', string='Sessions')
     current_session_id = fields.Many2one('pop.session', compute='_compute_current_session', string="Current Session")
@@ -41,13 +48,17 @@ class PopConfig(models.Model):
     pop_session_duration = fields.Char(compute='_compute_current_session_user')
     sequence_id = fields.Many2one('ir.sequence', string='Session sequence',
         help="Numbering of cash sessions.", copy=False)
+    allow_concurrent_sessions = fields.Boolean('allow concurrent sessions')
+    max_diff = fields.Float('Payment max diff')
+    current_concurrent_session_ids = fields.Many2many('pop.session', compute='_compute_current_session', string="Current Sessions")
 
     _sql_constraints = [('uniq_name', 'unique(code, company_id)', "Code is unic by company")]
 
     @api.model_create_multi
     def create(self, vals_list):
         for vals in vals_list:
-            if not vals['sequence_id']:
+            allow_concurrent_sessions  = vals.get('allow_concurrent_sessions', True)
+            if 'sequence_id' not in vals and not allow_concurrent_sessions:
                 vals['sequence_id'] = self.env['ir.sequence'].sudo().create([{
                             'name': 'session %s' % vals['code'],
                             'padding': 6,
@@ -78,16 +89,29 @@ def _compute_current_session(self):
             session = pop.session_ids.filtered(lambda r: r.state != 'closed')
             # sessions ordered by id desc
             pop.current_session_id = session and session[0].id or False
+            pop.current_concurrent_session_ids = session and session.ids or False
             pop.current_session_state = session and session[0].state or False
 
-    def open_session_cb(self):
+    def action_open_config(self):
+        view = self.env.ref('point_of_payment.pop_config_view_form')
+        return {
+            'name': ('Config'),
+            'view_type': 'form',
+            'view_mode': 'form,tree',
+            'res_model': 'pop.config',
+            'res_id': self.id,
+            'view_id': view.id,
+            'type': 'ir.actions.act_window',
+        }
+
+    def action_open_session(self):
         """ new session button
 
         create one if none exist
         access cash control interface if enabled or start a session
         """
         self.ensure_one()
-        if not self.current_session_id:
+        if not self.current_session_id or self.allow_concurrent_sessions:
             self.current_session_id = self.env['pop.session'].create({
                 'user_ids': [(4,self.env.uid)],
                 'pop_id': self.id
@@ -96,6 +120,7 @@ def open_session_cb(self):
         return self._open_session(self.current_session_id.id)
 
     def _open_session(self, session_id):
+        view = self.env.ref('point_of_payment.view_pop_session_form')
         return {
             'name': ('Session'),
             'view_type': 'form',