public void ChangeConditionAtIndex(int index, string newCondition)
{
Conditions[index].Object.Condition = newCondition;
Conditions.Refresh();
OnDataChanged?.Invoke();
OnRefresh?.Invoke();
}
// Used only on UserSignIn!
public static void SaveAll(bool notifyListeners = true)
{
AskToSaveLocal();
if (notifyListeners)
{
OnDataChanged?.Invoke();
}
}
/// <summary>
/// 取消订阅消息
/// </summary>
/// <param name="type"></param>
/// <param name="handler"></param>
public void Unsubscribe(DataChangeType type, OnDataChanged handler)
{
if (!messageEventTable.ContainsKey(type))
{
messageEventTable[type] = null;
}
messageEventTable[type] = (OnDataChanged)messageEventTable[type] - handler;
}
public int Delete(Expression <Func <T, bool> > whereExpression)
{
using (var context = GetContext())
{
OnDataChanged?.BeginInvoke(this, new DataChangedEventArgs <T>(ChangedTypes.Deleted), null, null);
return(context.Set <T>().Where(whereExpression).Delete());
}
}
public void Edit(string id, ImageInfo newInfo)
{
var target = GetById(id);
target.Copy(newInfo);
OnDataChanged?.Invoke(target);
}
public void Remove(string id)
{
var target = GetById(id);
_data.Remove(target);
OnDataChanged?.Invoke(target);
}
public void Create(ImageInfo info)
{
info.GenerateID( );
_data.Add(info);
OnDataChanged?.Invoke(info);
}
public int Insert(T entity)
{
using (var context = GetContext())
{
OnDataChanged?.BeginInvoke(this, new DataChangedEventArgs <T>(ChangedTypes.Inserted), null, null);
context.Set <T>().Add(entity);
return(context.SaveChanges());
}
}
public bool DeleteData(string ActionId, object[] parameters)
{
DataChangedEventArgs e = new DataChangedEventArgs
{
ActionId = ActionId,
ChangedData = parameters
};
OnDataChanged?.Invoke(this, e);
return(true);
}
private void DataChanged()
{
OnDataChanged?.Invoke();
CategoryModel currentCategory = OnNeededCurrentCategory?.Invoke();
if (currentCategory == null)
{
return;
}
GetData(currentCategory);
}
/// <summary>
/// 导入Excel
/// </summary>
public ParseResult ImportExcel(Workbook workbook)
{
var result = importExcel(workbook);
if (result == ParseResult.Success)
{
IsEdited = true;
OnDataChanged?.Invoke(Datas[DataIndex]);
OnStateChanged?.Invoke(HasPrevious, HasNext, !IsCreateNew, CanDelete, IsEdited);
}
return(result);
}
public void AddNewDefaultCondition()
{
if (!HasData)
{
return;
}
((IList <ConditionHolder>)Conditions.DataSource).Add((ConditionHolder)"Bel([x]) = True");
Conditions.Refresh();
OnDataChanged?.Invoke();
OnRefresh?.Invoke();
}
public void Update()
{
if (actionTimeStemp != timeStamp)
{
actionTimeStemp = timeStamp;
if (OnDataChanged != null)
{
//or OnDataChanged();
OnDataChanged.Invoke();
}
}
}
public void RemoveConditionAt(int index)
{
if (!HasData)
{
return;
}
Conditions.DataSource.RemoveAt(index);
Conditions.Refresh();
OnDataChanged?.Invoke();
OnRefresh?.Invoke();
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="type"></param>
/// <param name="objs"></param>
public void RaiseEvent(DataChangeType type, params object[] objs)
{
Delegate handler;
if (messageEventTable.TryGetValue(type, out handler))
{
OnDataChanged dc = (OnDataChanged)handler;
if (dc != null)
{
dc(type, objs);
}
}
}
public void AddNewTask(int offset)
{
Tasks.Add(new JobTask
{
ProjectJob = Jobs.OrderBy(x => x.Id).FirstOrDefault(),
Hours = 0.5,
Date = AddBusinessDays(DateTime.Today, offset, 0),
TaskType = TaskType.Normal,
Id = Guid.NewGuid()
});
OnDataChanged?.Invoke();
SaveTasks(Tasks);
}
/// <summary>
/// 导入Excel
/// </summary>
public ParseResult ImportExcel(Workbook workbook)
{
var result = importExcel(workbook);
if (result == ParseResult.Success)
{
//0711TODO KO 获取对应的NodeCode的ElementIds
Datas[DataIndex].LoadData(1);
IsEdited = true;
OnDataChanged?.Invoke(Datas[DataIndex]);
OnStateChanged?.Invoke(HasPrevious, HasNext, !IsCreateNew, CanDelete, IsEdited);
}
return(result);
}
private void LoadJson(string filePath)
{
if (!File.Exists(filePath))
{
Debug.Log("No existing JSON file");
}
using (var reader = new StreamReader(filePath))
{
var strdata = reader.ReadToEnd();
fsJsonParser.Parse(strdata, out _data);
object deserialized = null;
Serializer.TryDeserialize(_data, typeof(Entity), ref deserialized).AssertSuccessWithoutWarnings();
// wtf pretty much describes it, FS decides to create a new game object, this gets rid of it
var wtf = GameObject.Find("New Game Object");
if (wtf != null)
{
UnityEngine.Object.DestroyImmediate(wtf);
}
if (deserialized != null)
{
//return deserialized as Entity;
_newEnt = (Entity)deserialized;
foreach (var comp in _newEnt.Components)
{
if (!ComponentPools.ContainsKey(comp.ComponentType))
{
ComponentPools[comp.ComponentType] = new List <ComponentEcs>();
}
ComponentPools[comp.ComponentType].Add(comp);
#if UNITY_EDITOR
if (!GroupedComponents.ContainsKey(comp.Grouping))
{
GroupedComponents[comp.Grouping] = new List <ComponentEcs>();
}
GroupedComponents[comp.Grouping].Add(comp);
#endif
}
ShouldPoolEntity = _newEnt.IsPooled;
}
else
{
Debug.Log("Not deserialized");
}
}
OnDataChanged?.Invoke();
AvoidDirtyFlag = true;
}
public IEnumerable <T> Insert(IEnumerable <T> entities)
{
using (var context = GetContext())
{
OnDataChanged?.BeginInvoke(this, new DataChangedEventArgs <T>(ChangedTypes.Inserted), null, null);
context.Set <T>().AddRange(entities);
var result = context.SaveChanges();
if (result > 0)
{
return(entities);
}
return(null);
}
}
public void Insert(IEnumerable <T> entities)
{
using (var db = GetDbContext())
{
try
{
db.Insert(entities).Execute();
}
finally
{
OnDataChanged?.Invoke(this, new DataChangedEventArgs <T>(ChangedTypes.Inserted)
{
Data = entities
});
}
}
}
public dynamic Insert(T entity)
{
using (var db = GetDbContext())
{
try
{
return(db.Insert(entity).Execute());
}
finally
{
OnDataChanged?.Invoke(this, new DataChangedEventArgs <T>(ChangedTypes.Inserted)
{
Data = entity.AsIEnumerable()
});
}
}
}
public int Update(object entity, Expression <Func <T, bool> > whereExpression)
{
using (var db = GetDbContext())
{
var result = db.Update <T>().Set(entity).Where(whereExpression).Execute();
if (result > 0)
{
var data = db.Select <T>().Where(whereExpression).QueryMany();
OnDataChanged?.Invoke(this, new DataChangedEventArgs <T>(ChangedTypes.Updated)
{
Data = data
});
}
return(result);
}
}
public bool InsertData(string ActionId, object[] parameters)
{
try
{
DataChangedEventArgs e = new DataChangedEventArgs
{
ActionId = ActionId,
ChangedData = parameters
};
OnDataChanged?.Invoke(this, e);
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
public void MoveCondition(int index, int moveAmount)
{
AssetBounds(index);
var newIndex = index + moveAmount;
AssetBounds(index);
var l = Conditions.DataSource;
var obj = l[index];
l.RemoveAt(index);
l.Insert(newIndex, obj);
Conditions.Refresh();
OnDataChanged?.Invoke();
OnRefresh?.Invoke();
}
public async Task Start()
{
_client = new HttpClient();
var stream = await _client.GetStreamAsync(Host);
var reader = new StreamReader(stream);
string eventName = null;
string data = null;
while (_client != null)
{
var line = await reader.ReadLineAsync();
if (string.IsNullOrEmpty(line) || line.StartsWith(":"))
{
eventName = data = null;
continue;
}
if (line.StartsWith("event: "))
{
eventName = line.Substring("event: ".Length).Trim();
}
else if (line.StartsWith("data: "))
{
data = line.Substring("data: ".Length).Trim('"');
switch (eventName)
{
case "data_changed":
OnDataChanged?.Invoke(JsonConvert.DeserializeObject <JToken>(data));
break;
case "layout_changed":
OnLayoutChanged?.Invoke(data);
break;
}
}
}
this.Stop();
}
public void AddChosenComponent()
{
if (!ComponentPools.ContainsKey(TypeToCreate))
{
ComponentPools[TypeToCreate] = new List <ComponentEcs>();
}
var comp = (ComponentEcs)Activator.CreateInstance(ComponentFactory.ComponentLookup[TypeToCreate]);
ComponentPools[TypeToCreate].Add(comp);
#if UNITY_EDITOR
if (!GroupedComponents.ContainsKey(comp.Grouping))
{
GroupedComponents[comp.Grouping] = new List <ComponentEcs>();
}
GroupedComponents[comp.Grouping].Add(comp);
#endif
OnDataChanged?.Invoke();
IsDirty = true;
}
/// <summary>
/// 处理订阅事件
/// </summary>
/// <param name="item"></param>
/// <param name="e"></param>
private void OnMonitoredNotification(MonitoredItem item, MonitoredItemNotificationEventArgs e)
{
MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification;
var node = e.NotificationValue as NodeId;
var opcUaDataItem = this.OpcUaDataItems.FirstOrDefault(a => a.Name == item.ResolvedNodeId.ToString());
if (!Equals(opcUaDataItem, null))
{
opcUaDataItem.OldValue = opcUaDataItem.NewValue;
opcUaDataItem.NewValue = notification?.Value.Value;
opcUaDataItem.OpcUaStatusCodes = (OpcUaStatusCodes)notification?.Value.StatusCode.Code;
OpcUaDataEventArgs args = new OpcUaDataEventArgs(opcUaDataItem.OpcUaStatusCodes, opcUaDataItem);
OnDataChanged?.BeginInvoke(this, args, new AsyncCallback((a) =>
{
if (a.IsCompleted)
{
OnDataChanged?.EndInvoke(a);
}
}), null);
}
}
public void Rollback(bool isDeleteNew = false)
{
if (IsCreateNew && isDeleteNew)
{
MemorableData = null;
Datas.RemoveAt(DataIndex);
}
else
{
//0509 09:57 在编辑后回退,无编辑不回退
if (IsEdited)
{
MemorableData.Rollback();
if (Datas.Count > 0)
{
Datas[DataIndex] = MemorableData.Data;
}
OnDataChanged?.Invoke(Datas[DataIndex]);
OnStateChanged?.Invoke(HasPrevious, HasNext, CanCreateNew, CanDelete, CanSave);
}
}
}
/// <summary>
/// 更改选中项
/// </summary>
/// <param name="index"></param>
void ChangeCurrent(int index)
{
bool isContinue;
isContinue = CheckChanges();
if (!isContinue)
{
return;
}
DataIndex = index;
if (index > Datas.Count - 1)//只有新增时index超过Datas的最大值
{
IsCreateNew = true;
Datas.Add(createNew());
}
else
{
IsCreateNew = false;
}
UpdateMemorableData();//将选中内容刷到MemorableData
OnDataChanged?.Invoke(Datas[DataIndex]);
OnStateChanged?.Invoke(HasPrevious, HasNext, CanCreateNew, CanDelete, CanSave);
}
public void FireDataChange()
{
OnDataChanged?.Invoke(this, EventArgs.Empty);
}
