I know what SRP is, but am questioning my current design of an object I call an entity. Below is a picture of the design I am referring to. If I shift the code from the GeometricInformation and TransactionInformation objects to the abstracts GeometricEntityBase and TranslactionalEntityBase respectively, would this be considered a severe breech of SRP? I'm hoping the experts here can help poke holes in this design or affirm it if appropriate.
To summarize the intent, I have a CAD API I'm working on. Each entity in the CAD realm is represented by an Entity in code. To allow Entities to only carry those attributes appropriate to its purpose there's three levels of inheritance the Entity can use. For example, if only the very basic Entity features (like having an ID, etc) then it can just inherit from EntityBase. If it requires additional geometric properties to identify boundaries, insert point, transformation matrix, etc, then it would inherit from GeometricEntityBase. If it is to be a fully transacted entity (via a custom transactional framework), then it is required to carry the attributes of both plus transactional (such as the entity state (new, clean, dirty), document, etc).
To ensure SRP, I used the adapter pattern and set the geometric attributes and operations to an object called GeometricInformation and likewise the transactional stuff to TransactionInformation. This is working great, but I am now beginning to realize that in order to allow changes to geometric properties, I need to validate against the entity state. In otherwords, the GeometricInformation object has to know about the attributes of the TransactionInformation object. Solutions seem to involve an observer pattern such that the GeomtetricInformation could observe the TransactionInformation (which seems forceful) or assert an XXXEntityBase property "CanModify" that can be changed and observed by either XXXInformation object. Unfortunately this would create a two-way dependency since each XXXInformation object would have to know it's parent.
Because of the additional fact that WCF is used to communicate the entities to a lower-level data layer, there's also a translation process to convert these to DTO equivalents. In the end, I'm thinking of moving the code from the XXXInformation objects to their abstract equivalents which has very little in them anyways, but am concerned that breaking SRP would potentially cause downstream issues too. On the otherhand, this would streamline the entities more and allow the translation process to improve in terms of performance too so definitely some give-and-take.