public List <OrderModel> LoadRepositoryData()
{
List <OrderModel> vOrders = new List <OrderModel>();
FullData fData = FullLoad();
foreach (Order order in fData.Orders)
{
Auto auto = fData.Autos.Find(item => item.Id == order.IdAuto);
Owner owner = fData.Owners.Find(item => item.Id == auto.IdOwner);
OrderModel vOrder = new OrderModel
{
Id = order.Id,
NameJob = order.NameJob,
DateBegin = order.DateBegin,
DateEnd = order.DateEnd,
Price = order.Price,
Brand = auto.Brand,
Model = auto.Model,
YearOfIssue = auto.YearOfIssue,
Transmission = auto.Transmission,
Power = auto.Power,
Name = owner.Name,
Surname = owner.Surname,
Patronymic = owner.Patronymic,
Number = owner.Number,
YearOfBirth = owner.YearOfBirth
};
vOrders.Add(vOrder);
}
return(vOrders);
}
public async Task Response()
{
var buffer = new byte[1024 * 4];
string fullData = FullData.ToString();
byte[] byteArray = _l4D2AppHost.HostSettings.Encoding.GetBytes(fullData);
await WebSocket.SendAsync(new ArraySegment <byte>(byteArray, 0, byteArray.Length),
WebSocketMessageType.Text, true, CancellationToken.None);
WebSocketReceiveResult result =
await WebSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
while (!result.CloseStatus.HasValue)
{
string text = _l4D2AppHost.HostSettings.Encoding.GetString(buffer).Trim('\0');
if (result.MessageType == WebSocketMessageType.Text)
{
Console.WriteLine(text);
}
await WebSocket.SendAsync(new ArraySegment <byte>(buffer, 0, result.Count), result.MessageType,
result.EndOfMessage, CancellationToken.None);
result = await WebSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
}
await WebSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}
private void proc_OutputDataReceived(object sender, DataReceivedEventArgs e)
{
if (!IsLoading)
{
Console.WriteLine($"[{DateTime.Now.ToLongTimeString()}] Started outputting.");
IsLoading = true;
}
timer.Stop();
timer.Start();
//
string data = e.Data;
if (data == null)
{
return;
}
string subString = RemoveTimeAndInfo(data);
if (subString.IndexOf("<") == 0)
{
AddMessage(subString);
}
//db.UseInsert("INSERT INTO tbl_console VALUES (@date, @cmd)", new MySqlParameter("date", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")), new MySqlParameter("@cmd", data));
FullData.AppendLine(data);
bufferedData.AppendLine(data);
}
static void Main(string[] args)
{
logger.Info("START!");
logger.Info("Getting data...");
FullData data = crawler.Crawl();
logger.Info("Getting data done.");
logger.Info("DONE! Press Enter to terminate...");
Console.ReadLine();
}
//Считывание всего
FullData FullLoad()
{
FullData fData = new FullData();
// CreateFile();
using (FileStream stream = new FileStream(path, FileMode.Open))
{
BinaryFormatter formatter = new BinaryFormatter();
fData = (FullData)formatter.Deserialize(stream);
stream.Close();
return(fData);
}
}
public void SendCompleted(object Sender, SocketEventArgs E)
{
if (Status == SenderStatus.Sending)
{
if (SendedLength < DataLength)
{
Buffer = new byte[DataLength - SendedLength < BufferLength ?
DataLength - SendedLength : BufferLength];
Buffer = FullData.Skip(SendedLength).Take(Buffer.Length).ToArray();
E.Socket.SendAsync(Buffer); //从内存中读取二进制流，并发送
SendedLength += Buffer.Length;
}
else
{
Status = SenderStatus.Ready;
}
}
else if (Status == SenderStatus.Preparing)
{
Status = SenderStatus.Sending;
Buffer = new byte[BufferLength];
MemoryStream.Position = 0; //将流的当前位置重新归0，否则Read方法将读取不到任何数据
if (SendedLength < DataLength)
{
Buffer = new byte[DataLength - SendedLength < BufferLength ?
DataLength - SendedLength : BufferLength];
Buffer = FullData.Skip(SendedLength).Take(Buffer.Length).ToArray();
E.Socket.SendAsync(Buffer); //从内存中读取二进制流，并发送
SendedLength += Buffer.Length;
}
}
SendOnce?.Invoke(this, new SendOnceEventArgs()
{
Socket = Socket,
NewData = Buffer,
CumulativeLength = SendedLength,
ReceivedLength = Buffer.Length,
TotalLength = DataLength,
Status = Status
});
}
async private void Button_Click(object sender, RoutedEventArgs e)
{
progressBar.Visibility = Visibility.Visible;
exportBtn.IsEnabled = false;
//DbAccess da = new DbAccess();
await da.InitCon();
dt = await da.ExecuteQuery();
// var masterDatas = new List<MasterData>();
await Task.Factory.StartNew(() =>
{
// var masterDatas = new List<MasterData>();
mainMasterData = ts.GetDataTables(dt);
var result = mainMasterData.SelectMany(m => m.ReferenceRanges, (MasterData, ReferenceRange) => new { MasterData, ReferenceRange }).ToList();
foreach (var item in result)
{
FullData f = new FullData()
{
PanelId = item.MasterData.PanelId,
PanelName = item.MasterData.PanelName,
TestId = item.MasterData.TestId,
TestName = item.MasterData.TestName,
LabsectionId = item.MasterData.LabsectionId,
Labsection = item.MasterData.Labsection,
Units = item.MasterData.Units,
TubeId = item.MasterData.TubeId,
TubeName = item.MasterData.TubeName,
SampleTypeId = item.MasterData.SampleTypeId,
SampleTypeName = item.MasterData.SampleTypeName,
RefRangeType = item.ReferenceRange.RefRangeType,
Sex = item.ReferenceRange.Sex,
SpecialPeriod = item.ReferenceRange.SpecialPeriod,
TimeScale = item.ReferenceRange.TimeScale,
From = item.ReferenceRange.From,
To = item.ReferenceRange.To,
DiscardLow = item.ReferenceRange.DiscardLow,
PanicLow = item.ReferenceRange.PanicLow,
RefRange = item.ReferenceRange.RefRange,
PanicHigh = item.ReferenceRange.PanicHigh,
DiscardHigh = item.ReferenceRange.DiscardHigh
};
fD.Add(f);
}
});
progressBar.Visibility = Visibility.Collapsed;
using (SaveFileDialog sf = new SaveFileDialog
{
Filter = "Excel File|*.xlsx",
Title = "Save an Excel File"
})
{
sf.ShowDialog();
var name = sf.FileName;
if (name != "")
{
FileInfo f = new FileInfo(name);
ExportClass ex = new ExportClass(fD, f);
progressBar.Visibility = Visibility.Visible;
await ex.Export();
progressBar.Visibility = Visibility.Collapsed;
exportBtn.IsEnabled = true;
System.Windows.MessageBox.Show("File created!");
}
}
}
public void ExecuteActions(Item Item, RoomActor Actor)
{
Random rnd = new Random();
foreach (Item ActionItem in mInstance.GetItemsOnPosition(Item.RoomPosition.GetVector2()))
{
if (ActionItem.Definition.Behavior == ItemBehavior.WiredEffect)
{
ActionItem.DisplayFlags = "1";
ActionItem.BroadcastStateUpdate(mInstance);
ActionItem.DisplayFlags = "2";
ActionItem.RequestUpdate(4);
switch (WiredTypesUtil.EffectFromInt(ActionItem.Definition.BehaviorData))
{
#region show_message
case WiredEffectTypes.show_message:
if (Actor == null)
{
continue;
}
Actor.Whisper(mWired [ActionItem.Id].Data1, 0, true);
break;
#endregion
#region move_rotate
case WiredEffectTypes.move_rotate:
if (ActionItem.WiredData.Data2 == 0 && ActionItem.WiredData.Data3 == 0)
{
continue;
}
String[] ItemsToMove = ActionItem.WiredData.Data1.Split('|');
foreach (String toMove in ItemsToMove)
{
uint ItemId;
uint.TryParse(toMove, out ItemId);
Item Move = mInstance.GetItem(ItemId);
if (Move == null)
{
continue;
}
Vector2 NewPosition = new Vector2(Move.RoomPosition.X, Move.RoomPosition.Y);
switch (ActionItem.WiredData.Data2)
{
case 1:
switch (rnd.Next(1, 5))
{
case 1:
NewPosition = new Vector2(Move.RoomPosition.X - 1, Move.RoomPosition.Y);
break;
case 2:
NewPosition = new Vector2(Move.RoomPosition.X + 1, Move.RoomPosition.Y);
break;
case 3:
NewPosition = new Vector2(Move.RoomPosition.X, Move.RoomPosition.Y + 1);
break;
case 4:
NewPosition = new Vector2(Move.RoomPosition.X, Move.RoomPosition.Y - 1);
break;
}
break;
case 2:
if (rnd.Next(0, 2) == 1)
{
NewPosition = new Vector2(Move.RoomPosition.X - 1, Move.RoomPosition.Y);
}
else
{
NewPosition = new Vector2(Move.RoomPosition.X + 1, Move.RoomPosition.Y);
}
break;
case 3:
if (rnd.Next(0, 2) == 1)
{
NewPosition = new Vector2(Move.RoomPosition.X, Move.RoomPosition.Y - 1);
}
else
{
NewPosition = new Vector2(Move.RoomPosition.X, Move.RoomPosition.Y + 1);
}
break;
case 4:
NewPosition = new Vector2(Move.RoomPosition.X, Move.RoomPosition.Y - 1);
break;
case 5:
NewPosition = new Vector2(Move.RoomPosition.X + 1, Move.RoomPosition.Y);
break;
case 6:
NewPosition = new Vector2(Move.RoomPosition.X, Move.RoomPosition.Y + 1);
break;
case 7:
NewPosition = new Vector2(Move.RoomPosition.X - 1, Move.RoomPosition.Y);
break;
}
int NewRotation = Move.RoomRotation;
switch (ActionItem.WiredData.Data3)
{
case 1:
NewRotation = NewRotation + 2;
if (NewRotation == 8)
{
NewRotation = 0;
}
break;
case 2:
NewRotation = (NewRotation - 2);
if (NewRotation == -2)
{
NewRotation = 6;
}
break;
case 3:
if (rnd.Next(0, 2) == 1)
{
goto case 1;
}
else
{
goto case 2;
}
}
bool IsRotationOnly = (ActionItem.WiredData.Data2 == 0);
Vector3 FinalizedPosition = mInstance.SetFloorItem(null, Move, NewPosition, NewRotation);
if (FinalizedPosition != null)
{
Move.MoveToRoom(null, mInstance.RoomId, FinalizedPosition, NewRotation, "");
RoomManager.MarkWriteback(Move, false);
mInstance.RegenerateRelativeHeightmap();
mInstance.BroadcastMessage(RoomItemUpdatedComposer.Compose(Move));
ItemEventDispatcher.InvokeItemEventHandler(null, Move, mInstance, ItemEventType.Moved, IsRotationOnly ? 1 : 0);
}
}
break;
#endregion
#region match_to_sshot
case WiredEffectTypes.match_to_sshot:
String[] Selected = ActionItem.WiredData.Data5.Split('+');
foreach (String FullData in Selected)
{
if (!FullData.Contains('#'))
{
continue;
}
String[] Data = FullData.Split('#');
if (Data.Length != 4)
{
continue;
}
uint Id = uint.Parse(Data [0]);
String[] Position = Data [1].Split('|');
int Rotation = int.Parse(Data [2]);
String Flags = Data [3];
int X = int.Parse(Position [0]);
int Y = int.Parse(Position [1]);
uint Z = uint.Parse(Position [2]);
Item AffectedItem = mInstance.GetItem(Id);
if (AffectedItem == null)
{
continue;
}
Boolean IsRotationOnly = (X == AffectedItem.RoomPosition.X && Y == AffectedItem.RoomPosition.Y && Z == AffectedItem.RoomPosition.Z);
Vector2 NewPosition = new Vector2(X, Y);
if (ActionItem.WiredData.Data2 == 1)
{
AffectedItem.Flags = Flags;
AffectedItem.DisplayFlags = Item.Flags;
AffectedItem.BroadcastStateUpdate(mInstance);
}
if (ActionItem.WiredData.Data3 == 0)
{
Rotation = AffectedItem.RoomRotation;
}
if (ActionItem.WiredData.Data4 == 0)
{
NewPosition = AffectedItem.RoomPosition.GetVector2();
}
if (ActionItem.WiredData.Data4 == 1 || ActionItem.WiredData.Data3 == 1)
{
Vector3 FinalizedPosition = mInstance.SetFloorItem(null, AffectedItem, NewPosition, Rotation);
AffectedItem.MoveToRoom(null, mInstance.RoomId, FinalizedPosition, Rotation, "");
RoomManager.MarkWriteback(AffectedItem, false);
mInstance.RegenerateRelativeHeightmap();
mInstance.BroadcastMessage(RoomItemUpdatedComposer.Compose(AffectedItem));
ItemEventDispatcher.InvokeItemEventHandler(null, AffectedItem, mInstance, ItemEventType.Moved, IsRotationOnly ? 1 : 0);
}
else if (ActionItem.WiredData.Data2 == 1)
{
RoomManager.MarkWriteback(AffectedItem, true);
}
}
break;
#endregion
case WiredEffectTypes.teleport_to:
if (Actor == null)
{
continue;
}
String[] Selected2 = ActionItem.WiredData.Data1.Split('|');
String ItemIdS = Actor.FurniOnId.ToString();
while (Actor.FurniOnId.ToString() == ItemIdS)
{
ItemIdS = Selected2 [rnd.Next(0, Selected2.Length)];
}
uint ItemId2;
uint.TryParse(ItemIdS, out ItemId2);
Item AffectedItem2 = mInstance.GetItem(ItemId2);
if (AffectedItem2 == null)
{
continue;
}
Actor.PositionToSet = AffectedItem2.RoomPosition.GetVector2();
Actor.UpdateNeeded = true;
break;
case WiredEffectTypes.toggle_state:
String[] Selected3 = ActionItem.WiredData.Data1.Split('|');
foreach (String ItemIdS2 in Selected3)
{
uint ItemId3;
uint.TryParse(ItemIdS2, out ItemId3);
Item AffectedItem3 = mInstance.GetItem(ItemId3);
if (AffectedItem3 == null)
{
continue;
}
int CurrentState = 0;
int.TryParse(AffectedItem3.Flags, out CurrentState);
int NewState = CurrentState + 1;
if (CurrentState < 0 || CurrentState >= (AffectedItem3.Definition.BehaviorData - 1))
{
NewState = 0;
}
if (CurrentState != NewState)
{
AffectedItem3.Flags = NewState.ToString();
AffectedItem3.DisplayFlags = AffectedItem3.Flags;
RoomManager.MarkWriteback(AffectedItem3, true);
AffectedItem3.BroadcastStateUpdate(mInstance);
}
}
break;
}
}
}
}
private Promise InternalFullUpdate()
{
Deferred deferred = new Deferred();
if (!IsRegistered)
{
deferred.Reject();
return(deferred.Promise());
}
UserInfo userInfo = ServiceLocator.Resolve <IStorageService>().ResolveData <UserInfo>() ?? new UserInfo();
if (!userInfo.AddedScoreBalance.IsEmpty())
{
userInfo.NotSyncedScoreBalances.Add(Guid.NewGuid().ToString(), userInfo.AddedScoreBalance);
}
userInfo.AddedScoreBalance = new ScoreBalance();
FullData fullData = new FullData();
fullData.AddScoreDatas =
userInfo.NotSyncedScoreBalances.Select(
pair => new AddScoreData {
Token = pair.Key, Score = pair.Value.Score, Values = pair.Value.Balance
})
.ToArray();
fullData.AchievementIds =
((AchievementService)ServiceLocator.Resolve <IAchievementService>()).GetNotSyncAchievementIds();
fullData.PurchasedItemIds = ((StoreService)ServiceLocator.Resolve <IStoreService>()).GetNotPurchasableIds();
if (fullData.AddScoreDatas.Length == 0 && fullData.AchievementIds.Length == 0 &&
fullData.PurchasedItemIds.Length == 0)
{
deferred.Resolve();
return(deferred.Promise());
}
ServiceLocator.Resolve <IServerService>().CallTokenFull <FullDataResult>("FullUpdateData", fullData).Then(
result =>
{
UserInfo info = ServiceLocator.Resolve <IStorageService>().ResolveData <UserInfo>() ?? new UserInfo();
info.Score = result.UserData.Score;
info.Balance = result.UserData.Values;
if (!userInfo.AddedScoreBalance.IsEmpty())
{
info.Score += userInfo.AddedScoreBalance.Score;
info.Balance += userInfo.AddedScoreBalance.Balance;
}
info.NotSyncedScoreBalances = new Dictionary <string, ScoreBalance>();
ServiceLocator.Resolve <IStorageService>().UpdateData(info);
ServiceLocator.Resolve <IServerService>().Call <ServerAchievement[]>("GetAchievements", null).Then(
achievements =>
{
ServiceLocator.Resolve <IServerService>()
.Call <string[]>("GetClaimedAchievements", null)
.Then(
claimedAchievements =>
{
((AchievementService)ServiceLocator.Resolve <IAchievementService>())
.OnServerAchievementResolved(
achievements.ToDictionary(achievement => achievement.AchievementId,
achievement =>
new AchievementService.ServerAchievementInfo
{
Balance = new Balance {
Values = achievement.Values
},
Score = achievement.Score
}), claimedAchievements);
ServiceLocator.Resolve <IServerService>().Call <ServerPurchasableItem[]>("GetItems", null).Then(
items =>
{
ServiceLocator.Resolve <IServerService>().Call <string[]>("GetPurchasedItems", null).Then(
purchasedItems =>
{
((StoreService)ServiceLocator.Resolve <IStoreService>())
.OnServerPurchaseResolved(
items.ToDictionary(item => item.ItemId,
item => new ItemCosts
{
Purchase =
new Balance {
Values = item.PurchaseCost
},
Rent = new Balance {
Values = item.RentCost
}
}), purchasedItems);
deferred.Resolve();
}, () => deferred.Reject());
}, () => deferred.Reject());
}, () => deferred.Reject());
}, () => deferred.Reject());
}, () => deferred.Reject());
return(deferred.Promise());
}
public NBACrawlerBase()
{
data = new FullData();
}
