This question is locked. New answers and comments are not allowed.
Hi, Open Access team.
We are pleasant that you're still full of enthusiasm in the utility development.
I have used it to develop a new invoice payment module in our company system.
This time I trusted to it absolutely. The users edit a view object attribute. The view object sends a message to an Invoice persistent object. The invoice object code creates new Inoice payment (connected to several credit notes maybe). Then, the code groups invoice payments into a single remittance of a specific type and attached it to a batch.
The module passed all the tests. But we still have some problems. The most important one is when we almost sent several double payments to the bank.
Nobody can reproduce this bug.
A widely-spread commit errors are 'It is not allowed to read or write an instance marked for a deletion' or an error about duplicated OIDs. Ok, probably I tried to access to a deleted instance.
The only difference with the previous modules is that the view object updates the persistent objects immediately when the user changes the [Paid] attribute.
I can imagine that I could do mistakes in my programming, because it is difficult to manage a complex objects graph. But I can imagine that it is much more difficult to manage delayed changes of that complex objects graph. And maybe there are possible even theoretical problems there.
The user can place some amount into the [Paid] attribute (Invoice -> Invoice Payment -> Remittance -> Batch). Then clear it. Then place another amount. Or can do many other things that we don't know.
What the method would you suggest?
I mean every abstraction does 90% automatically but needs for 10% of 'manual efforts'
Should I break down the process onto view logic transactions? When no persistent objects (maybe not all of them) will be changed untill the user accepted all the changes.
I'm douing it actually. But Is this correct using of an ORM utility?
Or open access will do everything by itself?
And I just should worry about my own bugs? :-)
We are pleasant that you're still full of enthusiasm in the utility development.
I have used it to develop a new invoice payment module in our company system.
This time I trusted to it absolutely. The users edit a view object attribute. The view object sends a message to an Invoice persistent object. The invoice object code creates new Inoice payment (connected to several credit notes maybe). Then, the code groups invoice payments into a single remittance of a specific type and attached it to a batch.
The module passed all the tests. But we still have some problems. The most important one is when we almost sent several double payments to the bank.
Nobody can reproduce this bug.
A widely-spread commit errors are 'It is not allowed to read or write an instance marked for a deletion' or an error about duplicated OIDs. Ok, probably I tried to access to a deleted instance.
The only difference with the previous modules is that the view object updates the persistent objects immediately when the user changes the [Paid] attribute.
I can imagine that I could do mistakes in my programming, because it is difficult to manage a complex objects graph. But I can imagine that it is much more difficult to manage delayed changes of that complex objects graph. And maybe there are possible even theoretical problems there.
The user can place some amount into the [Paid] attribute (Invoice -> Invoice Payment -> Remittance -> Batch). Then clear it. Then place another amount. Or can do many other things that we don't know.
What the method would you suggest?
I mean every abstraction does 90% automatically but needs for 10% of 'manual efforts'
Should I break down the process onto view logic transactions? When no persistent objects (maybe not all of them) will be changed untill the user accepted all the changes.
I'm douing it actually. But Is this correct using of an ORM utility?
Or open access will do everything by itself?
And I just should worry about my own bugs? :-)