private async void GetTemperatureAsync()
{
System.Net.HttpStatusCode status;
(_data, status) = await GetDataAsync(Field, _dataCount);
//(_data, status) = await getDataAsync(Field);
if (status.Equals(System.Net.HttpStatusCode.OK))
{
ShowNoConnIcon?.Invoke(false);
ChannelName = GetChannelName();
FieldName = GetFieldName(Field);
SetNameLabel?.Invoke(ChannelName, FieldName);
List <Data <dynamic> > dataList = new List <Data <dynamic> >();
for (int i = 0; i < _data.Feeds.Count; i++)
{
string value = TemperatureFromFieldAsync(_data, i);
if (value != null)
{
string[] dateTime = _data.Feeds[i].created_at.Split('T');
string[] time = Regex.Split(dateTime[1], @"(?=[+-])");
DateTime date = Convert.ToDateTime(dateTime[0] + " " + time[0]);
dataList.Add(new Data <dynamic>()
{
date = date, value = value
});
}
}
SetTemperatureLabel?.Invoke(dataList[dataList.Count - 1].value);
SetUpdateDataLabel?.Invoke(dataList[dataList.Count - 1].date);
SetData?.Invoke(dataList);
}
else if (status.Equals(System.Net.HttpStatusCode.ServiceUnavailable))
{
ShowNoConnIcon?.Invoke(true);
}
if (!status.Equals(System.Net.HttpStatusCode.OK) && _internetConnection)
{
_internetConnection = false;
Stop();
_tmpRefreshTime = RefreshTime;
RefreshTime = 1000;
Start();
}
else if (status.Equals(System.Net.HttpStatusCode.OK) && !_internetConnection)
{
_internetConnection = true;
Stop();
RefreshTime = _tmpRefreshTime;
Start();
}
GC.Collect(2, GCCollectionMode.Forced);
}
public async Task SaveSetData(SetData setData)
{
await _setDataCollection.ReplaceOneAsync(x => x.SetId == setData.SetId && x.ModelId == setData.ModelId, setData, new UpdateOptions
{
IsUpsert = true
});
}
void UpdateSoundsSetsCount()
{
string[] texturesNames = terrain.terrainData.splatPrototypes.GetArrayOf(delegate(SplatPrototype splat) { return(splat.texture.name); });
List <SetData> newSet = new List <SetData>();
SetData tempObj;
for (int x = 0; x < texturesNames.Length; x++)
{
tempObj = new SetData(texturesNames[x]);
for (int y = 0; y < sets.Count; y++)
{
if (sets[y].TextureName == texturesNames[x])
{
tempObj.Set = sets[y].Set;
break;
}
}
newSet.Add(tempObj);
}
sets = newSet;
}
private void Start()
{
SetData data = JsonConvert.DeserializeObject <SetData>(ResourceEngine.Instance.Load <TextAsset>("FRF").text);
if (data != null)
{
Debug.Log(data.name);
Debug.LogError(data.code);
Debug.LogWarning(data.releaseDate);
Debug.LogException(new NotImplementedException("shit"));
//foreach (object boo in data.booster)
//{
// if (boo is ICollection)
// {
// foreach (object obj in (ICollection) boo)
// {
// Debug.Log(obj);
// }
// }
// else
// {
// Debug.Log(boo);
// }
//}
}
}
public void show(SetData sd)
{
this.sd = sd;
Show();
str.Clear();
value.Text = "";
}
public async Task <IActionResult> PostAsync([FromBody] SetData Data)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
CameraInfo cameraInfo = new CameraInfo {
CameraId = Data.CameraId,
Description = Data.Description,
ImageDataArray = Data.ImageDataArray,
ImageDatatype = Data.ImageDatatype,
ImageDateTime = Data.ImageDateTime,
ImageName = Data.ImageName,
ImageUnicId = Data.ImageUnicId,
ImageUrl = Data.ImageUrl
};
_unitOfWork.CameraInfoRepository.Insert(cameraInfo);
await _unitOfWork.CameraInfoRepository.Save();
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
protected void btnAdd_Click(object sender, EventArgs e)
{
SetData sd = new SetData();
sd.CreateItem(1, 0, txtName.Text, txtDescription.Text, txtPrice.Text, txtImage.Text, txtType.Text);
Response.Write("<script>alert('Item Created');</script>");
Response.Redirect("RestaurantManageMenu.aspx");
}
protected void Submit_Click(object sender, EventArgs e)
{
SetData set = new SetData(Adcat.SelectedValue, Atitle.Text, Adesc.Text, Adslot.SelectedIndex.ToString(), Adprior.SelectedIndex.ToString(), Adimg.FileBytes, Adimg.FileName);
StoreData sdata = new StoreData(set, res);
dbres.Controls.Add(res);
//Response.AddHeader("REFRESH", "2;url=Index.aspx");
}
public void ChangeCurrentSetLayer(SetData layer)
{
Data.CurrentSetLayer = layer;
Program.MainUIInvoke(() =>
{
Program.MainForm.UpdateTitle(Stage.ID);
});
}
public static void LoadSetLayerResources(GameEntry gameType,
SetData setData, bool loadModels = true)
{
foreach (var obj in setData.Objects)
{
LoadObjectResources(gameType, obj, loadModels);
}
}
private void NewToolStripMenuItem_Click(object sender, EventArgs e)
{
SetData = new ColorsSetData();
LoadedFilePath = null;
saveToolStripMenuItem.Enabled = false;
saveAsToolStripMenuItem.Enabled = true;
UpdateObjects();
}
public static CharacterSelectScreen GetCharacterSelectScreen(SetData _currentSetData, IRenderer _renderer)
{
List <MenuItem> items = new List <MenuItem>();
items.Add(new MenuItem(STR_SWEEP, 0, 0));
items.Add(new MenuItem(STR_DASH, 1, 0));
items.Add(new MenuItem(STR_ARMOR, 2, 0));
return(new CharacterSelectScreen(items, _currentSetData, _renderer));
}
protected void btnUpdate_Click(object sender, EventArgs e)
{
GetData gd = new GetData();
DataSet ds = gd.GetItem(Session["getItemID"].ToString());
SetData sd = new SetData();
sd.UpdateItem(Session["getItemID"].ToString(), Convert.ToInt32(ds.Tables[0].Rows[0]["RestrauntID"]), txtName.Text, txtDescription.Text, txtPrice.Text, txtImage.Text, txtType.Text);
Response.Write("<script>alert('Item Updated');</script>");
Response.Redirect("RestaurantManageMenu.aspx");
}
private static int UpdateProgress(SetData set, object lockObject, int progress, float max)
{
lock (lockObject)
{
Console.SetCursorPosition(0, Console.CursorTop);
Console.Write($"Downloading {set.Name.PadRight(25)} - {progress}/{max} ");
}
return(progress);
}
public void ThrowsExceptionIfFailsToLoadData()
{
var logger = Substitute.For <ILogger>();
var loader = CreateDataLoader(logger, new Timetable.Data());
var services = Substitute.For <IServiceCollection>();
var setData = new SetData(loader, logger);
Assert.Throws <InvalidDataException>(() => setData.ConfigureServices(services));
}
internal static ServiceConfigurations Find(Configuration config, ILogger logger)
{
logger.Information("Loading configuration", PluginDir);
var configurations = new ServiceConfigurations(logger);
AddInternalConfigurations();
AddExternalPlugins();
return(configurations);
void AddInternalConfigurations()
{
logger.Information("Loading internal service configuration", PluginDir);
var loader = Factory.CreateLoader(config, logger).Result;
var addData = new SetData(loader, logger);
configurations.Add(new Singletons());
configurations.Add(addData);
if (config.EnablePrometheusMonitoring)
{
configurations.Add(new ServiceConfiguration.Prometheus());
}
configurations.Add(new HealthCheck(addData, config.EnablePrometheusMonitoring));
configurations.Add(new Swagger());
configurations.Add(new ExceptionHandler());
}
void AddExternalPlugins()
{
if (!config.EnableCustomPlugins)
{
return;
}
try
{
logger.Information("Loading external plugins from {path}", PluginDir);
var conventions = new ConventionBuilder();
conventions.ForTypesDerivedFrom <IPlugin>().Export <IPlugin>().Shared();
var containerConfig = new ContainerConfiguration().WithAssembliesInPath(PluginDir, conventions);
using var container = containerConfig.CreateContainer();
var externalPlugins = container.GetExports <IPlugin>();
configurations.AddRange(externalPlugins);
}
catch (Exception e)
{
logger.Warning(e, "Error loading plugins from {path}", PluginDir);
}
}
}
private void SetDataToRTB(string msg)
{
if (this.InvokeRequired)
{
SetData setD = new SetData(SetDataToRTB);
this.Invoke(setD, new object[] { msg });
}
else
{
this.rtb_Data.Text = msg;
}
}
private void handleWorld(object client)
{
TcpClient tcpClient = (TcpClient)client;
World world = new World(tcpClient);
NetworkStream clientStream = tcpClient.GetStream();
byte[] message = new byte[4096];
int bytesRead;
while (true)
{
bytesRead = 0;
try
{
bytesRead = clientStream.Read(message, 0, 4096);
}
catch
{
break;
}
if (bytesRead == 0)
{
break;
}
IPacket packet = null;
switch (message[0])
{
case (byte)OpCodes.WL_REGISTER_WORLD: packet = new RegisterWorld(); break;
case (byte)OpCodes.WL_SET_DATA: packet = new SetData(); break;
}
packet.Write(message, 1, bytesRead - 1);
packet.Handle(world);
}
Log.Error("World.Listener", world.Name + " disconnected!");
try
{
Program.worlds.Remove((byte)world.Id);
lock (Worlds)
{
Worlds.Remove(world.Id);
}
tcpClient.Close();
}
catch (Exception e)
{
Log.Error("World.Listener", "Failed to remove disconnected world, exception:\n\n");
Console.WriteLine(e.ToString());
return;
}
}
public static void ImportSetLayerXML(string path)
{
// Import Set Layer from XML file
var setData = Types.SetDataType;
setData.Name = Path.GetFileNameWithoutExtension(path);
setData.ImportXML(path);
LoadSetLayerResources(Stage.GameType, setData);
// If a layer of the same name already exists, replace it.
int setIndex = -1;
for (int i = 0; i < SetLayers.Count; ++i)
{
if (SetLayers[i].Name == setData.Name)
{
setIndex = i;
break;
}
}
if (setIndex == -1)
{
SetLayers.Add(setData);
}
else
{
var layer = SetLayers[setIndex];
Viewport.SelectedInstances.Clear();
foreach (var obj in layer.Objects)
{
GetObject(obj, out VPModel mdl, out VPObjectInstance instance);
if (mdl == null || instance == null)
{
continue;
}
mdl.Instances.Remove(instance);
}
if (CurrentSetLayer == layer)
{
CurrentSetLayer = setData;
}
SetLayers[setIndex] = setData;
}
// Refresh the UI
GUI.RefreshSceneView();
GUI.RefreshGUI();
}
public void SaveDataCards()
{
SetData allCards = new SetData();
foreach (Card card in Singleton.instance.cardDictionary.Values)
{
allCards.data.Add(card);
}
string json = JsonUtility.ToJson(allCards, true);
string filePath = Singleton.instance.PathJsonFileLoaded;
File.WriteAllText(filePath, json);
}
public void HasLoadedData()
{
var logger = Substitute.For <ILogger>();
var loader = CreateDataLoader(logger);
var services = Substitute.For <IServiceCollection>();
var setData = new SetData(loader, logger);
setData.HasLoadedData.Should().BeFalse();
setData.ConfigureServices(services);
setData.HasLoadedData.Should().BeTrue();
}
protected virtual void ApplySet(SetData set)
{
if (set.Obj1 == null)
{
throw new ArgumentNullException("Obj1 Must Have A Value");
}
if (set.Obj2 == null)
{
throw new ArgumentNullException("Obj2 Must Have A Value");
}
set.Apply();
}
private void SetDataToMainForm(string url, string requestType, string msg)
{
if (this.InvokeRequired)
{
SetData setD = new SetData(SetDataToMainForm);
this.Invoke(setD, new object[] { url, requestType, msg });
}
else
{
this.tb_Url.Text = url;
this.cb_Request.Text = requestType;
this.rtb_Data.Text = msg;
}
}
private void Start()
{
SetData data = JsonConvert.DeserializeObject <SetData>(ResourceEngine.Instance.Load <TextAsset>("FRF").text);
foreach (CardData card in data.cards)
{
GameObject cardobj = ResourceEngine.Instance.Load <GameObject>("CardObj");
var cardgo = NGUITools.AddChild(grid.gameObject, cardobj).GetComponent <CardEntity>();
cardgo.data = card;
cardgo.GetComponent <CardRenderer>().frameSprite.gameObject.AddComponent <UICenterOnClick>().gameObject.AddComponent <UIDragScrollView>();
}
grid.Reposition();
}
public void SetEventData(SetData setData, DataEventArgs args)
{
if (args != null)
{
m_Args = args;
if (setData == SetData.HardWareData)
{
m_HardwareState = HardwareState.None;
}
else if (setData == SetData.TargetCoordinate)
{
m_HardwareState = HardwareState.SetTargetPose;
}
}
}
private List <ServiceDescriptor> ConfigureServices()
{
var descriptors = new List <ServiceDescriptor>();
var logger = Substitute.For <ILogger>();
var loader = CreateDataLoader(logger);
var services = Substitute.For <IServiceCollection>();
services.When(s => s.Add(Arg.Any <ServiceDescriptor>()))
.Do(args => descriptors.Add(args[0] as ServiceDescriptor));
var setData = new SetData(loader, logger);
setData.ConfigureServices(services);
return(descriptors);
}
public void LoadDataCards()
{
string filePath = Singleton.instance.PathJsonFile;
Singleton.instance.cardDictionary = new Dictionary <int, Card>();
if (File.Exists(filePath) && File.ReadAllText(filePath).Length > 0) //Si existe el arhivo y no esta vacio
{
var json = File.ReadAllText(filePath);
SetData cardsList = JsonUtility.FromJson <SetData>(json);
foreach (Card card in cardsList.data)
{
Singleton.instance.cardDictionary.Add(card.id, card);
}
}
Singleton.instance.DataRowViewComponent.ShowCardsInRows();
Singleton.instance.EnableButton("SaveButton");
Singleton.instance.EnableButton("AddButton");
Singleton.instance.PathJsonFileLoaded = filePath;
}
public void OpenSetData(string filePath)
{
if (!HasBeenInit)
{
Init();
}
Console.WriteLine("Opening SetData File: {0}", filePath);
LoadedFilePath = filePath;
SetData = new ColorsSetData();
if (filePath.ToLower().EndsWith(".orc"))
{
if (Path.GetDirectoryName(filePath).EndsWith("set"))
{
CPKDirectory = Directory.GetParent(Path.GetDirectoryName(filePath))
.FullName;
}
SetData.Load(filePath, TemplatesColors);
}
else if (filePath.ToLower().EndsWith(".xml"))
{
CreateObjectTemplateFromXMLSetData(filePath, true);
SetData.ImportXML(filePath);
}
else if (File.GetAttributes(filePath).HasFlag(FileAttributes.Directory))
{
CPKDirectory = Path.GetDirectoryName(filePath);
new SelectStageForm(this, Path.GetDirectoryName(filePath)).ShowDialog();
}
if (!string.IsNullOrEmpty(LoadedFilePath))
{
ReloadSetData_ToolStripMenuItem.Enabled = true;
}
saveToolStripMenuItem.Enabled = true;
saveAsToolStripMenuItem.Enabled = true;
Message($"Loaded {SetData.Objects.Count} Objects. Removing Unknown Objects");
// Remove SetObjects that have no templates
SetData.Objects.RemoveAll(t => string.IsNullOrEmpty(t.ObjectType));
Message($"Loaded {SetData.Objects.Count} Objects.");
UpdateObjects();
}
public OnlineGame(SetData _setData) : base(_setData)
{
_syncMessages = new List <SyncMessage>();
_selfSyncState = new List <SyncMessage>();
if (GameManager.Instance.NetplayState.IsFake)
{
InitGameplay();
}
else if (GameManager.Instance.NetplayState.IsHost)
{
_currentOnlineState = OnlineMatchState.WaitingForGuest;
}
else
{
_currentOnlineState = OnlineMatchState.WaitingForHost;
}
//online game needs several overrides :
//1. before starting a match there needs to be a synchronization phase
//2. need to send opponent inputs history during update
}
public static uint GenerateID(SetData setData)
{
bool taken = false;
for (uint i = 0; i < setData.Objects.Count; ++i)
{
taken = false;
foreach (var obj in setData.Objects)
{
if (obj.ObjectID == i)
{
taken = true;
}
}
if (!taken)
{
return(i);
}
}
return((uint)setData.Objects.Count);
}
