/// <summary>
/// 發生於特性狀態變更
/// </summary>
protected virtual void OnStatusChanged(PropertyStatus oldValue, PropertyStatus newValue)
{
if (StatusChanged != null)
{
StatusChanged(this, oldValue, newValue);
}
}
public void EnsureLoaded()
{
if (MuteNotify)
{
return;
}
IContext ctx = interceptable.GetInterceptor().Context;
IObjectManager om = ctx.ObjectManager;
PropertyStatus propStatus = om.GetPropertyStatus(interceptable, propertyName);
if (propStatus == PropertyStatus.NotLoaded)
{
ObjectStatus objStatus = om.GetObjectStatus(interceptable);
if (!(objStatus == ObjectStatus.UpForCreation))
{
bool stackMute = MuteNotify;
MuteNotify = true;
ctx.PersistenceEngine.LoadProperty(interceptable, propertyName);
MuteNotify = stackMute;
}
}
}
public async Task <OperationResult> ProcessAsync(long id, PropertyStatus status, string comment = null)
{
if (status != PropertyStatus.Realized && status != PropertyStatus.Reserved)
{
return(OperationResult.BadRequest);
}
var property = await _propertyRepository.GetAsync(id);
if (property == null)
{
return(OperationResult.NotFound);
}
await _propertyValidator.ValidateAsync(property, PropertyAction.Process);
property.Status = status;
_propertyRepository.Update(property);
if (!string.IsNullOrEmpty(comment))
{
// TODO: May be call service?
_commentRepository.Create(new Comment()
{
UserId = _identityService.GetUserId(),
PropertyId = id,
Text = comment
});
}
await _unitOfWork.SaveAsync();
return(OperationResult.Success);
}
private void SetStatusControl()
{
if (Template != null && DesignModeHelper.IsInDesignMode == false)
{
PropertyStatus status = GetTemplateChild("PART_PropertyStatus") as PropertyStatus;
if (status != null)
{
BindingExpression expression = GetBindingExpression(SelectedValueProperty);
if (expression != null &&
expression.ParentBinding != null &&
expression.ParentBinding.Path != null)
{
var binding = new Binding(expression.ParentBinding.Path.Path)
{
Source = expression.ParentBinding.Source
};
if (binding.Source == null)
{
binding.Source = DataContext;
}
status.SetBinding(PropertyStatus.PropertyProperty, binding);
status.TargetControl = this;
}
}
}
}
public void SetPropertyStatusOnAll(PropertyStatus value)
{
CameraMakePropertyStatus = value;
CameraModelPropertyStatus = value;
DisplayNamePropertyStatus = value;
ExtensionPropertyStatus = value;
FileAttributesPropertyStatus = value;
FileDateCreatedPropertyStatus = value;
FileDateModifiedPropertyStatus = value;
FileDirectoryPropertyStatus = value;
FileMimeTypePropertyStatus = value;
FileSizePropertyStatus = value;
FileSmartDatePropertyStatus = value;
LocationCityPropertyStatus = value;
LocationCountryPropertyStatus = value;
LocationDateTimePropertyStatus = value;
LocationNamePropertyStatus = value;
LocationRegionStatePropertyStatus = value;
LocationTimeZonePropertyStatus = value;
MediaAlbumPropertyStatus = value;
MediaAuthorPropertyStatus = value;
MediaCommentPropertyStatus = value;
MediaDateTakenPropertyStatus = value;
MediaDescriptionPropertyStatus = value;
MediaDimensionsPropertyStatus = value;
MediaRatingPropertyStatus = value;
MediaTitlePropertyStatus = value;
}
private void SaveProperty(PropertyStatus status) {
FillPropertyData();
property.Status = status;
property.Save();
FillPropertyEventData();
propertyEvent.Status = (PropertyEventStatus) (char) status;
propertyEvent.Save();
}
//public void Rent(Guid propertyId, Guid userId)
//{
// _propertiesRepository.RentProperty(propertyId, userId);
// _eventBus.Publish();
//}
public bool ChangePropertyRentStatus(Guid propertyId, Guid userId, PropertyStatus status)
{
var result = _propertiesRepository.ChangePropertyRentStatus(propertyId, userId, status);
_eventBus.Publish(CreateEvent(userId, propertyId, status));
return(result == 1);
}
public void SetStatus(int propertyId, PropertyStatus status)
{
// TODO: this needs to be license aware
VProperty dataModel = new VProperty {
PropertyId = propertyId, Status = status
};
Update(dataModel, x => x.Status);
}
public CachedListUpdate(IList cachedList, IList originalList, object obj, string propertyName, PropertyStatus propertyStatus, RefreshBehaviorType refreshBehavior)
{
this.cachedList = cachedList;
this.originalList = originalList;
this.obj = obj;
this.propertyName = propertyName;
this.propertyStatus = propertyStatus;
this.refreshBehavior = refreshBehavior;
}
public void SetStatus(int propertyId, PropertyStatus status)
{
using (DatabaseContext context = CreateDatabaseContext())
{
PropertyRepository propertyRepository = new PropertyRepository(context);
propertyRepository.SetStatus(propertyId, status);
context.SaveChanges();
}
}
public PropertyDTO(Property prop)
{
Id = prop.PropertyId;
LandlordId = prop.LandlordId;
Housenumber = prop.Housenumber;
Street = prop.Street;
Town = prop.Town;
PostCode = prop.PostCode;
AvailableFrom = prop.AvailableFrom;
Status = (PropertyStatus)Enum.Parse(typeof(PropertyStatus), prop.Status);
}
public PropertyDTO(PropertyDTO copy)
{
Id = copy.Id;
LandlordId = copy.LandlordId;
Housenumber = copy.Housenumber;
Street = copy.Street;
Town = copy.Town;
PostCode = copy.PostCode;
AvailableFrom = copy.AvailableFrom;
Status = copy.Status;
}
public int ChangePropertyRentStatus(Guid propertyId, Guid userId, PropertyStatus propertyStatus)
{
// todo: based on the bussiness conditions, this could throw if the user does not own the property
// should we catch this???
// maybe should catch the SQL exception with code 10000001 only ???
return(ExecuteQuery("sp_ChangePropertyRentStatus",
new[] {
new SqlParameter("@propertyId", propertyId),
new SqlParameter("@userId", userId),
new SqlParameter("@status", (int)propertyStatus)
}));
}
public PropertyStatus BuyRailroad(RailroadObj railroadObj, PropertyStatus propertySt)
{
if (Player.Money >= railroadObj.price)
{
propertySt.isBuyed = true;
propertySt.owner = Player.ID;
Player.railroads.Add(railroadObj);
Player.propertiesStat.Add(propertySt);
Player.Money -= railroadObj.price;
Debug.Log("player " + Player.ID + " buyed " + railroadObj.title + " for " + railroadObj.price + "| Now he got: " + Player.Money);
return(propertySt);
}
return(propertySt);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Contact>().OwnsOne(c => c.Address);
modelBuilder.Entity <Property>().OwnsOne(p => p.Address);
modelBuilder.Entity <SystemUser>().OwnsOne(u => u.Address);
modelBuilder.Entity <Team>().OwnsOne(t => t.Address);
modelBuilder.Entity <Organisation>().OwnsOne(o => o.Address);
modelBuilder.Entity <Property>().Property(p => p.Status).HasConversion(
p => p.Value,
p => PropertyStatus.FromValue(p));
}
public PropertyStatus BuyProperty(CardObject cardObj, PropertyStatus propertySt)
{
if (Player.Money >= cardObj.price)
{
propertySt.isBuyed = true;
propertySt.owner = Player.ID;
Player.properties.Add(cardObj);
Player.propertiesStat.Add(propertySt);
Player.Money -= cardObj.price;
Debug.Log("player " + Player.ID + " buyed " + cardObj.titleDeed + " for " + cardObj.price + "| Now he got: " + Player.Money);
return(propertySt);
}
return(propertySt);
}
public bool ChangeStatus(PropertyStatus status)
{
try
{
RealEntities db = new RealEntities();
property prop = db.properties.Where(p => p.property_id == PropertyId).FirstOrDefault();
prop.status = ( int )status;
db.SaveChanges();
return(true);
}
catch (Exception ex)
{
}
return(false);
}
public void ValidateObject(object obj, IList exceptions)
{
IObjectManager om = this.Context.ObjectManager;
IClassMap classMap = this.Context.DomainMap.MustGetClassMap(obj.GetType());
ValidationMode objValidationMode = GetValidationMode(classMap);
if (objValidationMode != ValidationMode.Off)
{
CustomValidateObject(obj, classMap, exceptions);
ObjectStatus objStatus = om.GetObjectStatus(obj);
foreach (IPropertyMap propertyMap in classMap.GetAllPropertyMaps())
{
ValidationMode validationMode = GetValidationMode(classMap, propertyMap);
if (validationMode != ValidationMode.Off)
{
PropertyStatus propStatus = om.GetPropertyStatus(obj, propertyMap.Name);
if (validationMode == ValidationMode.ValidateAll && objStatus != ObjectStatus.UpForCreation)
{
this.Context.ObjectManager.EnsurePropertyIsLoaded(obj, propertyMap);
}
if (objStatus == ObjectStatus.UpForCreation || propStatus != PropertyStatus.NotLoaded)
{
bool ok = false;
if (validationMode == ValidationMode.Default || validationMode == ValidationMode.ValidateLoaded || validationMode == ValidationMode.ValidateAll)
{
ok = true;
}
else if (validationMode == ValidationMode.ValidateDirty)
{
if (propStatus == PropertyStatus.Dirty)
{
ok = true;
}
}
if (ok)
{
DoValidateProperty(obj, propertyMap, exceptions);
}
}
}
}
}
}
private static PropertyEvent CreateEvent(Guid userId, Guid propertyId, PropertyStatus status)
{
var statusCode = (int)status;
if (statusCode == 2)
{
return(new PropertyRented(userId, propertyId));
}
if (statusCode == 1)
{
return(new PropertyOfferedForRent(userId, propertyId));
}
throw new ApplicationException(string.Format(@"Status '{0}' is not mapped to any event.", status));
}
private bool HasCount(ref int count)
{
IContext context = interceptable.GetInterceptor().Context;
PropertyStatus propStatus = context.ObjectManager.GetPropertyStatus(interceptable, propertyName);
if (propStatus != PropertyStatus.NotLoaded)
{
return(false);
}
IInverseHelper inverseHelper = interceptable as IInverseHelper;
if (inverseHelper == null)
{
return(false);
}
ITransaction tx = null;
ConsistencyMode readConsistency = context.ReadConsistency;
if (readConsistency == ConsistencyMode.Pessimistic)
{
IClassMap classMap = context.DomainMap.MustGetClassMap(interceptable.GetType());
ISourceMap sourceMap = classMap.GetSourceMap();
if (sourceMap != null)
{
if (sourceMap.PersistenceType.Equals(PersistenceType.ObjectRelational) || sourceMap.PersistenceType.Equals(PersistenceType.Default))
{
tx = context.GetTransaction(context.GetDataSource(sourceMap).GetConnection());
if (tx == null)
{
return(false);
}
}
}
}
if (inverseHelper.HasCount(propertyName, tx))
{
count = inverseHelper.GetCount(propertyName, tx);
return(true);
}
return(false);
}
/// <summary>
/// 集合內特性狀態變更動作
/// </summary>
private void ItemStatusChanged(object sender, PropertyStatus oldValue, PropertyStatus newValue)
{
PropertyBase item = sender as PropertyBase;
if (item.Affix == RunningBox.SpecialStatus.None)
{
return;
}
if (item.Status == PropertyStatus.Enabled)
{
_Affix |= item.Affix;
}
else
{
_AffixChanged = true;
}
}
public void ValidateObject(object obj, IList exceptions)
{
IObjectManager om = this.Context.ObjectManager;
IClassMap classMap = this.Context.DomainMap.MustGetClassMap(obj.GetType());
CustomValidateObject(obj, classMap, exceptions);
ObjectStatus objStatus = om.GetObjectStatus(obj);
foreach (IPropertyMap propertyMap in classMap.GetAllPropertyMaps())
{
PropertyStatus propStatus = om.GetPropertyStatus(obj, propertyMap.Name);
if (objStatus == ObjectStatus.UpForCreation || propStatus != PropertyStatus.NotLoaded)
{
DoValidateProperty(obj, propertyMap, exceptions);
}
}
}
private static IEnumerable <PropertyInfo> GetProperties(T start, T end, PropertyStatus status)
{
var @default = new T();
foreach (var info in typeof(T).GetProperties())
{
var priValue = info.GetGetMethod().Invoke(end, null);
var baseValue = info.GetGetMethod().Invoke(start, null);
var defaultValue = info.GetGetMethod().Invoke(@default, null);
var propertyChanged = !Equals(priValue, baseValue) &&
!Equals(priValue, defaultValue);
if (status == PropertyStatus.Changed && propertyChanged)
{
yield return(info);
}
else if (status == PropertyStatus.Unchanged && !propertyChanged)
{
yield return(info);
}
}
}
private void MergePrimitiveProperty(IObjectManager om, object obj, IClassMap classMap, IPropertyMap propertyMap, object existing, bool forOrgValue, PropertyStatus propStatus, PropertyStatus extPropStatus, MergeBehaviorType mergeBehavior)
{
if (forOrgValue)
{
object value = om.GetPropertyValue(obj, propertyMap.Name);
object extValue = om.GetPropertyValue(existing, propertyMap.Name);
MergePrimitivePropertyValues(value, extValue, propStatus, extPropStatus, om, existing, classMap, propertyMap, obj, forOrgValue, mergeBehavior);
}
else
{
object orgValue = om.GetOriginalPropertyValue(obj, propertyMap.Name);
object extOrgValue = om.GetOriginalPropertyValue(existing, propertyMap.Name);
MergePrimitivePropertyValues(orgValue, extOrgValue, propStatus, extPropStatus, om, existing, classMap, propertyMap, obj, forOrgValue, mergeBehavior);
}
}
private void SetSingleRefPropetyValue(bool forOrgValue, IObjectManager om, object existing, IPropertyMap propertyMap, object value, PropertyStatus propStatus)
{
IUnitOfWork uow = this.Context.UnitOfWork;
if (forOrgValue)
om.SetOriginalPropertyValue(existing, propertyMap.Name, value);
else
{
om.SetPropertyValue(existing, propertyMap.Name, value);
if (value == null)
om.SetNullValueStatus(existing, propertyMap.Name, true);
else
om.SetNullValueStatus(existing, propertyMap.Name, false);
if (propStatus == PropertyStatus.Dirty)
{
uow.RegisterDirty(existing);
om.SetUpdatedStatus(existing, propertyMap.Name, true);
}
}
}
private void MergeSingleRefProperty(IObjectManager om, object obj, IClassMap classMap, IPropertyMap propertyMap, object existing, bool forOrgValue, PropertyStatus propStatus, PropertyStatus extPropStatus, MergeBehaviorType mergeBehavior)
{
string extOrgObjId;
string refObjId;
object extRefObj;
object refObj;
object extOrgObj;
if (forOrgValue)
{
refObj = om.GetOriginalPropertyValue(obj, propertyMap.Name);
extOrgObj = om.GetOriginalPropertyValue(existing, propertyMap.Name);
}
else
{
refObj = om.GetPropertyValue(obj, propertyMap.Name);
extOrgObj = om.GetPropertyValue(existing, propertyMap.Name);
}
if (refObj != null && DBNull.Value.Equals(refObj) != true)
{
refObjId = om.GetObjectIdentity(refObj);
extOrgObjId = "";
if (extOrgObj != null)
extOrgObjId = om.GetObjectIdentity(extOrgObj);
if (!refObjId.Equals(extOrgObjId))
{
bool keepExisting = KeepExistingValue(refObj, extOrgObj, mergeBehavior, classMap, propertyMap, existing, obj, propStatus, extPropStatus, forOrgValue);
if (keepExisting != true)
{
extRefObj = this.Context.GetObjectById(refObjId, refObj.GetType());
SetSingleRefPropetyValue(forOrgValue, om, existing, propertyMap, extRefObj, propStatus);
}
}
}
else
{
if (extOrgObj != null)
{
bool keepExisting = KeepExistingValue(refObj, extOrgObj, mergeBehavior, classMap, propertyMap, existing, obj, propStatus, extPropStatus, forOrgValue);
if (keepExisting)
{
SetSingleRefPropetyValue(forOrgValue, om, existing, propertyMap, null, propStatus);
}
}
}
}
public void SetStatus(int propertyId, PropertyStatus status)
{
_propertyDataProvider.SetStatus(propertyId, status);
}
private void NullifyInverseReference(IPropertyMap propertyMap, object obj, IPropertyMap invPropertyMap, IObjectManager om)
{
bool stackMute = false;
IInterceptableList mList;
IList refList;
IList list;
object thisObj;
object refObj;
//Ensure that the property is loaded
if (this.Context.GetPropertyStatus(obj, propertyMap.Name) == PropertyStatus.NotLoaded)
{
this.Context.LoadProperty(obj, propertyMap.Name);
}
if (propertyMap.IsCollection)
{
list = (IList)om.GetPropertyValue(obj, propertyMap.Name);
if (list == null)
{
list = this.Context.ListManager.CreateList(obj, propertyMap);
}
if (list != null)
{
if (invPropertyMap.IsCollection)
{
foreach (object itemRefObj in list)
{
//Ensure inverse is loaded
PropertyStatus invPropertyStatus = this.Context.GetPropertyStatus(itemRefObj, invPropertyMap.Name);
if (invPropertyStatus == PropertyStatus.NotLoaded)
{
this.Context.LoadProperty(itemRefObj, invPropertyMap.Name);
}
refList = ((IList)(om.GetPropertyValue(itemRefObj, invPropertyMap.Name)));
if (refList.Contains(obj))
{
mList = refList as IInterceptableList;
if (mList != null)
{
stackMute = mList.MuteNotify;
mList.MuteNotify = true;
}
refList.Remove(obj);
if (mList != null)
{
mList.MuteNotify = stackMute;
}
om.SetUpdatedStatus(itemRefObj, invPropertyMap.Name, true);
}
}
}
else
{
foreach (object itemRefObj in list)
{
//Ensure inverse is loaded
PropertyStatus invPropertyStatus = this.Context.GetPropertyStatus(itemRefObj, invPropertyMap.Name);
if (invPropertyStatus == PropertyStatus.NotLoaded)
{
this.Context.LoadProperty(itemRefObj, invPropertyMap.Name);
}
thisObj = om.GetPropertyValue(itemRefObj, invPropertyMap.Name);
if (thisObj != null)
{
if (thisObj == obj)
{
om.SetPropertyValue(itemRefObj, invPropertyMap.Name, null);
om.SetUpdatedStatus(itemRefObj, invPropertyMap.Name, true);
}
}
}
}
}
}
else
{
refObj = om.GetPropertyValue(obj, propertyMap.Name);
if (refObj != null)
{
PropertyStatus invPropertyStatus = this.Context.GetPropertyStatus(refObj, invPropertyMap.Name);
//Ensure inverse is loaded
if (invPropertyStatus == PropertyStatus.NotLoaded)
{
this.Context.LoadProperty(refObj, invPropertyMap.Name);
}
if (invPropertyMap.IsCollection)
{
refList = ((IList)(om.GetPropertyValue(refObj, invPropertyMap.Name)));
if (refList.Contains(obj))
{
mList = refList as IInterceptableList;
if (mList != null)
{
stackMute = mList.MuteNotify;
mList.MuteNotify = true;
}
refList.Remove(obj);
if (mList != null)
{
mList.MuteNotify = stackMute;
}
om.SetUpdatedStatus(refObj, invPropertyMap.Name, true);
}
}
else
{
//only update back ref if it is actually pointing at me
thisObj = om.GetPropertyValue(refObj, invPropertyMap.Name);
if (thisObj != null)
{
if (thisObj == obj)
{
om.SetPropertyValue(refObj, invPropertyMap.Name, null);
om.SetUpdatedStatus(refObj, invPropertyMap.Name, true);
}
}
}
}
}
}
private void MergeListRefProperty(IObjectManager om, object obj, IClassMap classMap, IPropertyMap propertyMap, object existing, PropertyStatus propStatus, PropertyStatus extPropStatus, bool forOrgValue, MergeBehaviorType mergeBehavior)
{
IList list = ((IList) om.GetPropertyValue(obj, propertyMap.Name));
IList orgList = ((IList) om.GetPropertyValue(existing, propertyMap.Name));
MergeReferenceLists(list, orgList, om, obj, mergeBehavior, classMap, propertyMap, existing, propStatus, extPropStatus, forOrgValue);
}
private void RefreshProperty(IObjectManager om, object targetObject, IPropertyMap propertyMap, IPersistenceManager pm, RefreshBehaviorType refreshBehavior, object value, out bool doWrite, out bool doWriteOrg)
{
doWrite = false;
doWriteOrg = false;
PropertyStatus propStatus = om.GetPropertyStatus(targetObject, propertyMap.Name);
IClassMap classMap = this.Context.DomainMap.MustGetClassMap(targetObject.GetType());
RefreshBehaviorType useRefreshBehavior = pm.GetRefreshBehavior(refreshBehavior, classMap, propertyMap);
if (useRefreshBehavior == RefreshBehaviorType.OverwriteNotLoaded || useRefreshBehavior == RefreshBehaviorType.DefaultBehavior)
{
//Overwrite both value and original far all unloaded properties
if (propStatus == PropertyStatus.NotLoaded)
{
doWrite = true;
doWriteOrg = true;
}
}
else if (useRefreshBehavior == RefreshBehaviorType.OverwriteLoaded)
{
//Overwrite original for all properties
//Overwrite value for all clean or unloaded properties (but not for dirty or deleted properties)
doWriteOrg = true;
if (propStatus == PropertyStatus.Clean || propStatus == PropertyStatus.NotLoaded)
{
doWrite = true;
}
}
else if (useRefreshBehavior == RefreshBehaviorType.ThrowConcurrencyException)
{
//Overwrite original for all properties unless the old originial value and the fresh value from the
//database mismatch, in that case raise an exception
//Overwrite value for all clean or unloaded properties (but not for dirty or deleted properties)
if (propStatus == PropertyStatus.Clean || propStatus == PropertyStatus.NotLoaded || propStatus == PropertyStatus.Dirty)
{
if (!(propStatus == PropertyStatus.NotLoaded))
{
object testValue = om.GetOriginalPropertyValue(targetObject, propertyMap.Name);
object testValue2 = value;
if (DBNull.Value.Equals(testValue))
{
testValue = null;
}
if (DBNull.Value.Equals(testValue2))
{
testValue2 = null;
}
if (testValue2 != testValue)
{
string cachedValue = "null";
string freshValue = "null";
try
{
if (testValue != null)
{
cachedValue = testValue.ToString();
}
}
catch {; }
try
{
if (value != null)
{
freshValue = value.ToString();
}
}
catch {; }
throw new RefreshException("A refresh concurrency exception occurred when refreshing a cached object of type " + targetObject.GetType().ToString() + " with fresh data from the data source. The data source row has been modified since the last time this version of the object was loaded, specifically the value for property " + propertyMap.Name + ". (this exception occurs because ThrowConcurrencyExceptions refresh behavior was selected). Cashed value: " + cachedValue + ", Fresh value: " + freshValue, cachedValue, freshValue, targetObject, propertyMap.Name); // do not localize
}
}
if (!(propStatus == PropertyStatus.Dirty))
{
doWrite = true;
}
}
}
else if (useRefreshBehavior == RefreshBehaviorType.OverwriteDirty)
{
//Overwrite original for all properties
//Overwrite value for all clean, unloaded or dirty properties (but not for deleted properties)
doWriteOrg = true;
if (!(propStatus == PropertyStatus.Deleted))
{
doWrite = true;
}
}
else
{
throw new NPersistException("Unknown object refresh behavior specified!"); // do not localize
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.M))
{
Debug.Log("Player [" + playerScripts[i].Player.ID + "]: " + playerScripts[i].Player.Money + "$");
}
if (canBeReset && !playerControls[i].GetIsMoving() && !cardActive && cardEndTurn)
{
PropertyStatus property = propertiesStat.Find(x => x.id == playerControls[i].GetRoutePos());
cardEndTurn = false;
CheckCard(playerControls[i].GetRoutePos());
if (property.owner != 0)
{
PlayerRent(playerControls[i].GetRoutePos());
}
}
if ((Input.GetKeyDown(KeyCode.Q) || Input.GetKeyDown(KeyCode.C) || Input.GetKeyDown(KeyCode.X) || Input.GetKeyDown(KeyCode.Space)) && canBeReset && !playerControls[i].GetIsMoving())
{
if (Input.GetKeyDown(KeyCode.Q))
{
PropertyStatus property = propertiesStat.Find(x => x.id == playerControls[i].GetRoutePos());
if (property.isBuyed == false)
{
if (idsOfProp.Contains(playerControls[i].GetRoutePos()))
{
CardObject cardObject = JsonUtility.FromJson <CardObject>(Load(playerControls[i].GetRoutePos()));
property = playerScripts[i].BuyProperty(cardObject, property);
}
else if (idsOfRr.Contains(playerControls[i].GetRoutePos()))
{
RailroadObj rrObject = JsonUtility.FromJson <RailroadObj>(Load(playerControls[i].GetRoutePos()));
property = playerScripts[i].BuyRailroad(rrObject, property);
}
}
Debug.Log(property.id + " owner: " + property.owner);
}
else if (Input.GetKeyDown(KeyCode.C))
{
if (GameObject.Find("Canvas").transform.GetChild(1).gameObject.activeSelf == true || GameObject.Find("Canvas").transform.GetChild(3).gameObject.activeSelf == true)
{
ChangeCard(playerControls[i].GetRoutePos(), 2);
}
else if (GameObject.Find("Canvas").transform.GetChild(2).gameObject.activeSelf == true || GameObject.Find("Canvas").transform.GetChild(4).gameObject.activeSelf == true)
{
ChangeCard(playerControls[i].GetRoutePos(), 1);
}
}
else if (Input.GetKeyDown(KeyCode.X))
{
CheckCard(playerControls[i].GetRoutePos());
}
else
{
if (cardActive)
{
CheckCard(playerControls[i].GetRoutePos());
}
foreach (var dice in dices)
{
dice.Reset();
}
canBeReset = false;
Debug.Log("Dices has been Started/Reseted!");
i++;
if (i > countOfPlayers - 1)
{
i = 0;
}
cardEndTurn = true;
}
}
CheckTurn();
}
private void MergeSingleRefProperty(IObjectManager om, object obj, IClassMap classMap, IPropertyMap propertyMap, object existing, bool forOrgValue, PropertyStatus propStatus, PropertyStatus extPropStatus, MergeBehaviorType mergeBehavior)
{
string extOrgObjId;
string refObjId;
object extRefObj;
object refObj;
object extOrgObj;
if (forOrgValue)
{
refObj = om.GetOriginalPropertyValue(obj, propertyMap.Name);
extOrgObj = om.GetOriginalPropertyValue(existing, propertyMap.Name);
}
else
{
refObj = om.GetPropertyValue(obj, propertyMap.Name);
extOrgObj = om.GetPropertyValue(existing, propertyMap.Name);
}
if (refObj != null && DBNull.Value.Equals(refObj) != true)
{
//hmmmm won't this fail if we have two objects of different classes but with the same id?
//probably the type should be included (and preferably change to KeyStruct comparisons...)
refObjId = om.GetObjectIdentity(refObj);
extOrgObjId = "";
if (extOrgObj != null)
extOrgObjId = om.GetObjectIdentity(extOrgObj);
if (!refObjId.Equals(extOrgObjId))
{
bool keepExisting = KeepExistingValue(refObj, extOrgObj, mergeBehavior, classMap, propertyMap, existing, obj, propStatus, extPropStatus, forOrgValue);
if (keepExisting != true)
{
extRefObj = this.Context.GetObjectById(refObjId, refObj.GetType());
SetSingleRefPropetyValue(forOrgValue, om, existing, propertyMap, extRefObj, propStatus);
}
}
}
else
{
if (extOrgObj != null)
{
bool keepExisting = KeepExistingValue(refObj, extOrgObj, mergeBehavior, classMap, propertyMap, existing, obj, propStatus, extPropStatus, forOrgValue);
if (keepExisting)
{
SetSingleRefPropetyValue(forOrgValue, om, existing, propertyMap, null, propStatus);
}
}
}
}
public virtual void NotifyPropertyGet(object obj, string propertyName, ref object value, ref bool cancel)
{
if (this.isDisposed)
{
return;
}
if (notification == Notification.Disabled)
{
return;
}
ObjectStatus objStatus = this.Context.ObjectManager.GetObjectStatus(obj);
IPropertyMap propertyMap;
PropertyStatus propStatus = PropertyStatus.Clean;
bool hasPropertyStatus = false;
PropertyCancelEventArgs e = new PropertyCancelEventArgs(obj, propertyName, null, value, this.Context.ObjectManager.GetNullValueStatus(obj, propertyName));
this.Context.EventManager.OnReadingProperty(this, e);
if (e.Cancel)
{
cancel = true;
return;
}
value = e.value;
bool didLoadObject = false;
if (objStatus == ObjectStatus.Deleted)
{
throw new DeletedObjectException("The object has been deleted!", obj, propertyName); // do not localize
}
else if (objStatus == ObjectStatus.UpForDeletion)
{
throw new DeletedObjectException("The object has been registered as up for deletion!", obj, propertyName); // do not localize
}
else if (objStatus == ObjectStatus.NotLoaded)
{
propertyMap = this.Context.DomainMap.MustGetClassMap(obj.GetType()).MustGetPropertyMap(propertyName);
if (!(propertyMap.IsIdentity))
{
propStatus = this.Context.ObjectManager.GetPropertyStatus(obj, propertyName);
hasPropertyStatus = true;
//it would be sweet to be able to determine beforehand if this property would be part of the span
//that is loaded with LoadObject and only call LoadObject if that is the case....
if (propStatus == PropertyStatus.NotLoaded)
{
hasPropertyStatus = false;
//this.Context.PersistenceEngine.LoadObject(ref obj);
this.Context.IdentityMap.LoadObject(ref obj, true);
if (obj == null)
{
throw new ObjectNotFoundException("Object not found!"); // do not localize
}
didLoadObject = true;
}
}
}
if (!hasPropertyStatus)
{
propStatus = this.Context.ObjectManager.GetPropertyStatus(obj, propertyName);
}
if (propStatus == PropertyStatus.Clean)
{
if (didLoadObject)
{
value = this.Context.ObjectManager.GetPropertyValue(obj, propertyName);
}
}
if (propStatus == PropertyStatus.Deleted)
{
if (obj is IObjectHelper)
{
throw new DeletedObjectException("The object has been deleted!", obj, propertyName); // do not localize
}
}
else if (propStatus == PropertyStatus.NotLoaded)
{
if (!(objStatus == ObjectStatus.UpForCreation))
{
this.Context.PersistenceEngine.LoadProperty(obj, propertyName);
value = this.Context.ObjectManager.GetPropertyValue(obj, propertyName);
}
}
this.Context.InverseManager.NotifyPropertyGet(obj, propertyName);
}
//[DebuggerStepThrough()]
protected virtual void DoNotifyPropertySet(object obj, string propertyName, ref object value, object oldValue, bool hasOldValue, ref bool cancel)
{
IContext ctx = this.Context;
IObjectManager om = ctx.ObjectManager;
IPersistenceEngine pe = ctx.PersistenceEngine;
PropertyCancelEventArgs e;
if (hasOldValue)
{
e = new PropertyCancelEventArgs(obj, propertyName, value, oldValue, this.Context.ObjectManager.GetNullValueStatus(obj, propertyName));
}
else
{
e = new PropertyCancelEventArgs(obj, propertyName, value, this.Context.ObjectManager.GetPropertyValue(obj, propertyName), this.Context.ObjectManager.GetNullValueStatus(obj, propertyName));
}
this.Context.EventManager.OnWritingProperty(this, e);
if (e.Cancel)
{
cancel = true;
return;
}
value = e.NewValue;
IClassMap classMap = ctx.DomainMap.MustGetClassMap(obj.GetType());
IPropertyMap propertyMap;
string prevId;
string newId;
propertyMap = classMap.MustGetPropertyMap(propertyName);
if (propertyMap.ReferenceType != ReferenceType.None && value != null)
{
if (propertyMap.ReferenceType == ReferenceType.OneToMany || propertyMap.ReferenceType == ReferenceType.OneToOne)
{
//parent object
IInterceptable ivalue = value as IInterceptable;
if (ivalue == null)
{
throw new NPersistException(string.Format("Object is not a NPersist managed object, do not use 'new' on Entities. (Property='{0}', Owner={1})", propertyName, obj));
}
else
{
if (ivalue.GetInterceptor().Context != this.Context)
{
throw new NPersistException(string.Format("Object does not belong to the same context object as the property owner. (Property='{0}', Owner={1})", propertyName, obj));
}
ObjectStatus valueObjectStatus = om.GetObjectStatus(value);
if (valueObjectStatus == ObjectStatus.UpForDeletion || valueObjectStatus == ObjectStatus.Deleted)
{
throw new DeletedObjectException(string.Format("Object has been deleted. (Object={0})", value), value);
}
}
}
else if (propertyMap.ReferenceType == ReferenceType.ManyToOne || propertyMap.ReferenceType == ReferenceType.ManyToMany)
{
IInterceptableList ivalue = value as IInterceptableList;
if (ivalue == null)
{
throw new NPersistException(string.Format("List is not a NPersist managed list, do not use 'new' to initialize lists, NPersist does this for you. (Property='{0}', Owner={1})", propertyName, obj));
}
else if (ivalue.Interceptable.GetInterceptor().Context != this.Context)
{
throw new NPersistException(string.Format("List does not belong to the same context object as the property owner. (Property='{0}', Owner={1})", propertyName, obj));
}
}
}
if (propertyMap.IsReadOnly)
{
//Let read-only inverse properties through
if (!(propertyMap.ReferenceType != ReferenceType.None && propertyMap.Inverse.Length > 0 && propertyMap.NoInverseManagement == false))
{
//Special - if someone forgot to make their ManyOne read-only,
//why bug them about it? (so don't add an "else" with an exception...)
if (propertyMap.ReferenceType != ReferenceType.ManyToOne)
{
throw new ReadOnlyException("Property '" + classMap.Name + "." + propertyName + "' is read-only!"); // do not localize
}
}
}
PropertyStatus propStatus = PropertyStatus.Clean;
ObjectStatus objStatus = om.GetObjectStatus(obj);
bool hasPropertyStatus = false;
if (objStatus == ObjectStatus.Deleted)
{
throw new DeletedObjectException("The object has been deleted!", obj, propertyName); // do not localize
}
else if (objStatus == ObjectStatus.UpForDeletion)
{
throw new DeletedObjectException("The object has been registered as up for deletion!", obj, propertyName); // do not localize
}
this.Context.ObjectCloner.EnsureIsClonedIfEditing(obj);
if (objStatus == ObjectStatus.UpForCreation)
{
}
else if (objStatus == ObjectStatus.Clean)
{
propStatus = om.GetPropertyStatus(obj, propertyName);
if (propStatus == PropertyStatus.NotLoaded)
{
pe.LoadProperty(obj, propertyName);
}
if (!(hasOldValue))
{
if (!(om.ComparePropertyValues(obj, propertyName, value, om.GetPropertyValue(obj, propertyName))))
{
this.Context.UnitOfWork.RegisterDirty(obj);
}
}
}
else if (objStatus == ObjectStatus.NotLoaded)
{
propertyMap = this.Context.DomainMap.MustGetClassMap(obj.GetType()).MustGetPropertyMap(propertyName);
if (!(propertyMap.IsIdentity))
{
propStatus = this.Context.ObjectManager.GetPropertyStatus(obj, propertyName);
hasPropertyStatus = true;
//it would be sweet to be able to determine beforehand if this property would be part of the span
//that is loaded with LoadObject and only call LoadObject if that is the case....
if (propStatus == PropertyStatus.NotLoaded)
{
hasPropertyStatus = false;
//this.Context.PersistenceEngine.LoadObject(ref obj);
this.Context.IdentityMap.LoadObject(ref obj, true);
if (obj == null)
{
throw new ObjectNotFoundException("Object not found!"); // do not localize
}
}
if (!hasPropertyStatus)
{
propStatus = om.GetPropertyStatus(obj, propertyName);
}
if (propStatus == PropertyStatus.NotLoaded)
{
pe.LoadProperty(obj, propertyName);
}
}
if (!(hasOldValue))
{
if (!(om.ComparePropertyValues(obj, propertyName, value, om.GetPropertyValue(obj, propertyName))))
{
this.Context.UnitOfWork.RegisterDirty(obj);
}
}
}
else if (objStatus == ObjectStatus.Dirty)
{
propStatus = om.GetPropertyStatus(obj, propertyName);
if (propStatus == PropertyStatus.NotLoaded)
{
pe.LoadProperty(obj, propertyName);
}
}
if (propertyMap.IsIdentity)
{
prevId = om.GetObjectIdentity(obj);
newId = om.GetObjectIdentity(obj, propertyMap, value);
if (prevId != newId)
{
ctx.IdentityMap.UpdateIdentity(obj, prevId, newId);
}
}
om.SetNullValueStatus(obj, propertyName, false);
om.SetUpdatedStatus(obj, propertyName, true);
if (hasOldValue)
{
ctx.InverseManager.NotifyPropertySet(obj, propertyName, value, oldValue);
ctx.UnitOfWork.RegisterDirty(obj);
}
else
{
ctx.InverseManager.NotifyPropertySet(obj, propertyName, value);
}
}
public Response()
{
Found = new PropertyStatus();
NotFound = new PropertyStatus();
}
private void MergePrimitivePropertyValues(object value, object extValue, PropertyStatus propStatus, PropertyStatus extPropStatus, IObjectManager om, object existing, IClassMap classMap, IPropertyMap propertyMap, object obj, bool forOrgValue, MergeBehaviorType mergeBehavior)
{
if (!value.Equals(extValue)) // May be to naive - possibly should use some advanced method like ComparePropertyValues..
{
bool keepExisting = KeepExistingValue(value, extValue, mergeBehavior, classMap, propertyMap, existing, obj, propStatus, extPropStatus, forOrgValue);
if (!keepExisting)
{
if (forOrgValue)
{
om.SetPropertyValue(existing, propertyMap.Name, value);
om.SetNullValueStatus(existing, propertyMap.Name, om.GetNullValueStatus(obj, propertyMap.Name));
if (propStatus == PropertyStatus.Dirty)
{
this.Context.UnitOfWork.RegisterDirty(existing);
om.SetUpdatedStatus(existing, propertyMap.Name, true);
}
}
else
{
om.SetOriginalPropertyValue(existing, propertyMap.Name, value);
}
}
}
}
private bool KeepExistingValue(object value, object extValue, MergeBehaviorType mergeBehavior, IClassMap classMap, IPropertyMap propertyMap, object existing, object obj, PropertyStatus propStatus, PropertyStatus extPropStatus, bool forOrgValue)
{
bool keepExisting = false;
MergeBehaviorType useMergeBehavior = GetMergeBehavior(mergeBehavior, classMap, propertyMap);
if (useMergeBehavior == MergeBehaviorType.ThrowConcurrencyException)
throw new MergeException("Merge Conflict!", extValue, value, existing, obj, propertyMap.Name, forOrgValue);
//First try: Dirty wins..
if (propStatus == PropertyStatus.Dirty && extPropStatus == PropertyStatus.Dirty)
{
if (useMergeBehavior == MergeBehaviorType.DefaultBehavior)
throw new BothDirtyMergeException("Unresovable Merge Conflict! Both values are dirty!", extValue, value, existing, obj, propertyMap.Name, forOrgValue);
else if (useMergeBehavior == MergeBehaviorType.IgnoreConflictsUsingMergeValue)
keepExisting = false;
else if (useMergeBehavior == MergeBehaviorType.IgnoreConflictsUsingCashedValue)
keepExisting = true;
else
throw new NPersistException("This should be unreachable code...if it is not, that means I made a mistake!" );
}
else if (propStatus == PropertyStatus.Dirty)
keepExisting = false;
else if (extPropStatus == PropertyStatus.Dirty)
keepExisting = true;
else
{
//Second try: Clean wins
if (propStatus == PropertyStatus.Clean && extPropStatus == PropertyStatus.Clean)
{
if (useMergeBehavior == MergeBehaviorType.DefaultBehavior)
throw new BothCleanMergeException("Unresovable Merge Conflict! Both values are clean!", extValue, value, existing, obj, propertyMap.Name, forOrgValue);
else if (useMergeBehavior == MergeBehaviorType.IgnoreConflictsUsingMergeValue)
keepExisting = false;
else if (useMergeBehavior == MergeBehaviorType.IgnoreConflictsUsingCashedValue)
keepExisting = true;
else
throw new NPersistException("This should be unreachable code...if it is not, that means I made a mistake!" );
}
else if (propStatus == PropertyStatus.Clean)
keepExisting = false;
else if (extPropStatus == PropertyStatus.Clean)
keepExisting = true;
else
{
if (extPropStatus == PropertyStatus.NotLoaded)
keepExisting = false;
if (extPropStatus == PropertyStatus.Deleted)
keepExisting = true;
else
throw new NPersistException("This should be unreachable code...if it is not, that means I made a mistake!" );
}
}
return keepExisting;
}
public void TestINotifyPropertyChangingAndChanged()
{
if (this.ToTest == null)
{
throw new ArgumentNullException("item");
}
Dictionary <string, PropertyStatus> properties = new Dictionary <string, PropertyStatus>();
foreach (PropertyInfo property in this.ToTest.GetType().GetPublicProperties())
{
if (property.CanRead == false)
{
continue;
}
if (property.CanWrite == false)
{
continue;
}
if (properties.ContainsKey(property.Name) == false)
{
properties.Add(property.Name, PropertyStatus.NotCalled);
}
}
PropertyChangingEventHandler method1 = (o, e)
=>
{
if (properties.ContainsKey(e.PropertyName) == false)
{
throw new InvalidOperationException("The property '" + e.PropertyName + "' was not found on object type '" + typeof(T).FullName + "'");
}
properties[e.PropertyName] |= PropertyStatus.Changing;
};
PropertyChangedEventHandler method2 = (o, e)
=>
{
if (properties.ContainsKey(e.PropertyName) == false)
{
throw new InvalidOperationException("The property '" + e.PropertyName + "' was not found on object type '" + typeof(T).FullName + "'");
}
properties[e.PropertyName] |= PropertyStatus.Changed;
};
this.ToTest.PropertyChanging += method1;
this.ToTest.PropertyChanged += method2;
this._ModifyProperties();
this.ToTest.PropertyChanging -= method1;
this.ToTest.PropertyChanged -= method2;
bool returnValue = properties.Values.All((p) =>
{
return((p & PropertyStatus.Changed) > 0 && (p & PropertyStatus.Changing) > 0);
});
if (returnValue == false)
{
List <string> failedProperties = new List <string>();
foreach (string key in properties.Keys)
{
PropertyStatus propertyStatus = properties[key];
if (
((propertyStatus & PropertyStatus.Changed) == 0)
||
((propertyStatus & PropertyStatus.Changing) == 0)
)
{
failedProperties.Add(key);
}
}
Assert.Fail("{0} propert{1} ({2}) did not fire PropertyChanged or PropertyChanging.", failedProperties.Count, failedProperties.Count == 1 ? "y" : "ies", String.Join(", ", failedProperties));
}
}
private void MergeReferenceLists(IList list, IList orgList, IObjectManager om, object obj, MergeBehaviorType mergeBehavior, IClassMap classMap, IPropertyMap propertyMap, object existing, PropertyStatus propStatus, PropertyStatus extPropStatus, bool forOrgValue)
{
IList objectsToRemove = new ArrayList();
IList objectsToAdd = new ArrayList();
IUnitOfWork uow = this.Context.UnitOfWork;
foreach (object itemOrgObj in orgList)
{
string itemOrgObjId = om.GetObjectIdentity(itemOrgObj);
bool found = false;
foreach (object itemObj in list)
{
string itemObjId = om.GetObjectIdentity(itemObj);
if (itemObjId == itemOrgObjId)
{
found = true;
break;
}
}
if (!found)
objectsToRemove.Add(itemOrgObj);
}
foreach (object itemObj in list)
{
string itemObjId = om.GetObjectIdentity(itemObj);
bool found = false;
foreach (object itemOrgObj in orgList)
{
string itemOrgObjId = om.GetObjectIdentity(itemOrgObj);
if (itemObjId == itemOrgObjId)
{
found = true;
break;
}
}
if (!found)
{
object itemOrgObj = this.Context.GetObjectById(itemObjId, obj.GetType());
objectsToAdd.Add(itemOrgObj);
}
}
if (objectsToRemove.Count > 0 || objectsToAdd.Count > 0)
{
bool keepExisting = KeepExistingValue(list, orgList, mergeBehavior, classMap, propertyMap, existing, obj, propStatus, extPropStatus, forOrgValue);
if (!keepExisting)
{
bool stackMute = false;
IInterceptableList mList = orgList as IInterceptableList;
if (mList != null)
{
stackMute = mList.MuteNotify;
mList.MuteNotify = true;
}
foreach (object itemOrgObj in objectsToRemove)
orgList.Remove(itemOrgObj);
foreach (object itemOrgObj in objectsToAdd)
orgList.Add(itemOrgObj);
if (mList != null) { mList.MuteNotify = stackMute; }
if (propStatus == PropertyStatus.Dirty)
{
uow.RegisterDirty(existing);
om.SetUpdatedStatus(existing, propertyMap.Name, true);
}
}
}
}
public CachedListUpdate(IList cachedList, IList originalList, object obj, string propertyName, PropertyStatus propertyStatus, RefreshBehaviorType refreshBehavior)
{
this.cachedList = cachedList;
this.originalList = originalList;
this.obj = obj;
this.propertyName = propertyName;
this.propertyStatus = propertyStatus;
this.refreshBehavior = refreshBehavior;
}