private async Task OpenDocument(IDocument doc)
{
_openDocuments.Add(doc);
await Oy.Publish("Document:Opened", doc);
await ActivateDocument(doc);
}
/// <summary>
/// этот метод вызовет программа обновления службы, сообщив свою
/// локальную директорию и статус обновления
/// </summary>
public void UpdateServiceFilesStates(string serviceFolder, int filesUpdated, int filesLeft, bool updateFinished)
{
// найти сервис по директории
var map = ServiceMap.LoadSettings();
if (map.Items.Count == 0)
{
return;
}
var srv = map.Items.FirstOrDefault(m => m.Folder == serviceFolder);
if (srv == null)
{
Logger.DebugFormat("Информация по сервису в каталоге [{0}] - сервис не найден",
serviceFolder);
return;
}
if (updateFinished)
{
serviceStatus.TryRemove(s => s.ServiceName == srv.ServiceName, 2000);
return;
}
var srvStatus = new ServiceUpdateStatus
{
FilesLeft = filesLeft,
FilesUpdated = filesUpdated,
ServiceName = srv.ServiceName
};
serviceStatus.TryRemove(s => s.ServiceName == srv.ServiceName, 2000);
serviceStatus.Add(srvStatus, 2000);
}
/// <summary>
/// Add URL to the listing record
/// </summary>
/// <param name="url"></param>
public void AddFileListingTest(string url)
{
if (!ListingFilesTest.Contains(url))
{
ListingFilesTest.Add(url);
}
}
public void AddLimit(Limits limit)
{
if (!lstLimits.Any(t => t.Range == limit.Range))
{
lstLimits.Add(limit);
}
}
public void Setup()
{
list = new ThreadSafeList <string>();
for (int i = 0; i < 10; i++)
{
list.Add($"test {i}");
}
}
/// <summary>
/// Extract existing folders from a given list of URLs
/// </summary>
/// <param name="lsturls"></param>
/// <returns></returns>
private static ThreadSafeList <string> _ExtractFoldersRuntime(IEnumerable <string> lsturls)
{
var folders = new ThreadSafeList <string>();
var foldersBackups = new ThreadSafeList <string>();
foreach (var url in lsturls)
{
var u = new Uri(url);
if (u.ToString().EndsWith("//"))
{
var auxSingleUrl = new ThreadSafeList <string> {
u.ToString().Remove(u.ToString().Length - 1, 1)
};
return(_ExtractFoldersRuntime(auxSingleUrl));
}
var offSetProtocol = url.IndexOf("://", StringComparison.Ordinal);
var protocol = url.Substring(0, offSetProtocol);
var foldersSplit = u.AbsolutePath.Split('/');
var path = string.Empty;
for (var i = 0; i < foldersSplit.Length; i++)
{
if (i + 1 != foldersSplit.Length)
{
path += foldersSplit[i] + "/";
}
if (folders.Contains(protocol + "://" + u.Host + path) || path.Contains("."))
{
continue;
}
folders.Add(protocol + "://" + u.Host + path);
// ToDo use a list provided by the user
string[] compressExt = { ".zip", ".rar", ".tar", ".gz", ".tar.gz" };
var path1 = path;
foreach (
var extension in
compressExt.Where(
extension =>
protocol + "://" + u.Host + path1.Substring(0, path1.Length - 1) !=
protocol + "://" + u.Host)
.Where(
extension =>
!foldersBackups.Contains(protocol + "://" + u.Host +
path1.Substring(0, path1.Length - 1) +
extension)))
{
foldersBackups.Add(protocol + "://" + u.Host + path.Substring(0, path.Length - 1) +
extension);
}
}
}
return(foldersBackups);
}
public PanelInformationOptionsSerializableClass()
{
int nExtensions = 22;
for (int i = 0; i < nExtensions; i++)
{
files_Extensions.Add(true);
}
}
/// <summary>
/// Create the grid
/// </summary>
private void DrawGrid()
{
HelixGrid = null;
var newLines = new ThreadSafeList <Point3D>();
for (int x = -10; x <= 10; x++)
{
newLines.Add(new Point3D(x, -10, -.001));
newLines.Add(new Point3D(x, 10, -.001));
}
for (int y = -10; y <= 10; y++)
{
newLines.Add(new Point3D(-10, y, -.001));
newLines.Add(new Point3D(10, y, -.001));
}
HelixGrid = newLines;
}
public static ThreadSafeList <T> ToThreadSafeList <T>(this IEnumerable <T> collection)
{
ThreadSafeList <T> tsList = new ThreadSafeList <T>(collection.Count());
foreach (T item in collection)
{
tsList.Add(item);
}
return(tsList);
}
public void AddConnector(bool isInput, ConnectorObject connector)
{
if (isInput)
{
inputConveyors.Add(connector);
}
else
{
outputConveyors.Add(connector);
}
UpdateElectricityCost();
}
public void CreateRoomInternal(Room room)
{
room.Id = freeRoomId++;
// устанавливаем время, когда комната будет удалена из-за неактивности
if (!room.IsBound && !room.ExpireTime.HasValue)
{
room.ExpireTime = DateTime.Now + roomExpireTime;
}
var newRoom = new Room(room);
rooms.Add(newRoom, lockTimeout);
}
/// <summary>
/// Returns a URLs list for the ackups search action
/// </summary>
/// <param name="urls"></param>
/// <returns></returns>
public static ThreadSafeList <string> MutexFileRuntime(ThreadSafeList <string> urls)
{
var allUrls = new ThreadSafeList <string>();
var mutexfolders = _ExtractFoldersRuntime(urls);
foreach (var url in urls)
{
var uri = new Uri(url);
var file = Path.GetFileName(uri.LocalPath);
var fileName = Path.GetFileNameWithoutExtension(file);
var fileExtension = Path.GetExtension(file);
var path = uri.AbsoluteUri;
if (uri.AbsoluteUri.IndexOf(file, StringComparison.Ordinal) > 0)
{
path = path.Remove(uri.AbsoluteUri.IndexOf(file, StringComparison.Ordinal));
}
var mutex = _MutexFileRuntime(path, HttpUtility.UrlEncode(fileName),
HttpUtility.UrlEncode(fileExtension));
if (mutex == null)
{
return(allUrls);
}
foreach (var mutexUrl in mutex)
{
allUrls.Add(mutexUrl);
}
}
foreach (var folderMuteado in mutexfolders)
{
allUrls.Add(folderMuteado);
}
return(allUrls);
}
public void AddConveyor(TransportPipeInfo info)
{
if (info.type == PIPETYPE.Wooden)
{
if (linkerPipeType != PIPETYPE.Wooden)
{
linkerPipeType = PIPETYPE.Wooden;
UpdateElectricityType();
}
}
conveyors.Add(info);
UpdateElectricityCost();
}
void counterHandler(object sender, Image <Gray, byte> e)
{
mainRecognizer.TrainingImages = InsidePeoples.ToList();
mainRecognizer.SetImageLabels();
int index = mainRecognizer.RecogniseReturnLabel(e, 2000);
if (index == -1)
{
InsidePeoples.Add(e);
In = In + 1;
Debug.WriteLine("Person Entered");
}
}
void OnGUI()
{
if (spokenCommandFieldVisible)
{
spokenCommand = GUI.TextField(new Rect(0, 0, 200, 20), spokenCommand, 200);
if (Event.current.Equals(Event.KeyboardEvent("None")))
{
//Debug.Log("Pressed Enter");
//DoneTyping();
outgoingMessages.Add("SC," + spokenCommand + "\n");
spokenCommand = "";
}
}
}
public void AddLimit(Limits limit)
{
var found = false;
foreach (var t in lstLimits.Where(t => t.Range == limit.Range))
{
found = true;
}
if (found == false)
{
lstLimits.Add(limit);
}
}
public void ScheduleTaskOnSynchronizationCompleted(WaitCallback callback, object ptr = null)
{
if (wasSynchrnoizedAtLeastOneTime)
{
ThreadPool.QueueUserWorkItem(callback, ptr);
}
else
{
tasksPerformedOnSynchIsCompleted.Add(new SynchCompletedTask
{
callback = callback,
callbackParam = ptr
}, 2000);
}
}
/// <summary>
/// Adds the given transaction to the queue of transactions to send and wakes
/// up the write thread of the associated connection
/// </summary>
/// <param name="transaction">transactionToSend</param>
/// <param name="positionIndex">the position in which to add the transaction, if -1
/// (UNIMPORTANT) just run an .add</param>
private void AddTransactionToSend(Transaction transaction, int positionIndex)
{
lock (_transactionsToSendLock)
{
if (positionIndex != UNIMPORTANT)
{
_transactionsToSend.Insert(positionIndex, transaction);
}
else
{
_transactionsToSend.Add(transaction);
}
}
Connection.NotifyWriteThread();
}
public void AppendLogMessage(string msg)
{
logMessages.Add(DateTime.Now.ToString("HH:mm:ss") + " " + msg, 1000);
// отрезать линюю историю
if (logMessages.Count <= MaxMessagesInLog)
{
return;
}
bool timeout;
var subMsgList = logMessages.ExtractAll(1000, out timeout);
var countTarget = MaxMessagesInLog - ClearLogBy;
subMsgList = subMsgList.Skip(Math.Max(0, subMsgList.Count() - countTarget)).Take(countTarget).ToList();
logMessages.AddRange(subMsgList, 1000);
}
public ChatResultCode MoveToRoomWithNoAnswer(int userId, string roomName, string password, int requestId)
{
var user = users.Find(u => u.ID == userId, lockTimeout);
if (user == null)
{
Logger.InfoFormat("[{0}]MoveToRoomWithNoAnswer: user not found, room={1}", requestId, roomName);
return(ChatResultCode.UnknownUser);
}
var room = rooms.Find(r => r.Name == roomName, lockTimeout);
if (room == null)
{
Logger.InfoFormat("[{0}]MoveToRoomWithNoAnswer: room {1} not found, user={2}", requestId, roomName, user);
return(ChatResultCode.UnknownRoom);
}
bool timeoutFlag;
var userAndRoomExists = usersAndRooms.Contains(new Cortege2 <int, int> {
a = userId, b = room.Id
}, lockTimeout, out timeoutFlag);
if (userAndRoomExists)
{
return(ChatResultCode.AlreadyEnteredRoom);
}
// проверяем пароль
if (!string.IsNullOrEmpty(room.Password) && room.Password != password)
{
Logger.InfoFormat("[{0}]MoveToRoomWithNoAnswer: password not correct, user={1}, room={2}", requestId, user, roomName);
return(ChatResultCode.Error);
}
usersAndRooms.Add(new Cortege2 <int, int>(userId, room.Id), lockTimeout);
room.UserCount++;
// сбрасываем время автоматического удаления комнаты
room.ExpireTime = null;
Logger.InfoFormat("[{0}]MoveToRoomWithNoAnswer: user {1} entered room {2}", requestId, user, roomName);
var action = new UserAction
{
UserId = userId,
ActionType = UserActionType.RoomEnter,
Room = roomName,
TimeStamp = DateTime.Now
};
userActions.Add(action, lockTimeout);
SendUserAction(action);
return(ChatResultCode.Ok);
}
public void PutMessage(MessageCategory cat, string msg)
{
var upTime = messagePublished.ReceiveValue(cat);
if (upTime.HasValue)
{
var deltaSec = (DateTime.Now - upTime.Value).TotalSeconds;
if (deltaSec < minSecondsBetweenSameMessages)
{
return;
}
}
messages.Add(new Cortege2 <MessageCategory, string>(cat, msg), 1000);
messagePublished.UpdateValues(cat, DateTime.Now);
}
private void button1_Click(object sender, EventArgs e)
{
ThreadSafeList <string> list = new ThreadSafeList <string>();
Random rnd = new Random(DateTime.Now.Millisecond);
for (int i = 0; i < 10; i++)
{
list.Add(rnd.Next(1, 20).ToString());
}
string[] aa = { "A1", "B2", "C3", "D4" };
list.AddRange(aa);
MessageBox.Show("OK");
list = new ThreadSafeList <string>(aa);
list.RemoveAll(s => { int zz; return(!int.TryParse(s, out zz)); });
ThreadSafeCollection <string> cl = new ThreadSafeCollection <string>();
}
private void Process()
{
TaskFOCA task;
while (true)
{
System.Threading.Thread.Sleep(50);
for (int iTaskRunning = 0; iTaskRunning < lstRunningTasks.Count; iTaskRunning++)
{
TaskFOCA taskRunning = lstRunningTasks[iTaskRunning];
if (!taskRunning.IsAlive())
{
lstRunningTasks.Remove(taskRunning);
if (OnTaskFinished != null)
{
OnTaskFinished(taskRunning, null);
}
}
}
if (lstRunningTasks.Count >= Program.cfgCurrent.NumberOfTasks)
{
continue;
}
for (int iTask = lstRunningTasks.Count; iTask < Program.cfgCurrent.NumberOfTasks; iTask++)
{
if (lstTasks.Count == 0)
{
continue;
}
task = lstTasks.First();
lstTasks.Remove(task);
lstRunningTasks.Add(task);
task.Start();
if (OnTaskStarting != null)
{
OnTaskStarting(task, null);
}
}
}
}
private void UserEnteredInternal(UserAction action)
{
if (isStopping)
{
return;
}
// TODO: отвязать клиента от БД
var userData = AllUsers.Instance.GetUser(action.UserId) ?? new User {
ID = action.UserId, Login = action.UserId.ToString()
};
onlineUsers.Add(userData, LockTimeout);
if (UserEntered != null)
{
UserEntered(action);
}
}
public void Subscribe(Type messageType, MessageBusHandler handler)
{
_container.Lock(value =>
{
ThreadSafeList <MessageBusHandler> handlers;
if (value.TryGetValue(messageType, out handlers))
{
handlers.Add(handler);
}
else
{
handlers = new ThreadSafeList <MessageBusHandler>();
value.Add(messageType, handlers);
handlers.Add(handler);
}
});
}
public void AddTask(TaskFOCA task)
{
lstTasks.Add(task);
task.id = idCount;
try
{
idCount++;
}
catch
{
idCount = 0;
}
if (OnTaskAdded != null)
{
OnTaskAdded(task, null);
}
}
public PlayerSlotCollection(int numSlots)
{
SlotList = new ThreadSafeList<PlayerSlot>(numSlots);
PlayerSlot previous = null;
PlayerSlot current = null;
for (int i = 0; i < numSlots; i++)
{
current = new PlayerSlot(i, SyncLock);
if (previous != null)
previous.FillNextSlot(current);
SlotList.Add(current);
previous = current;
}
//-- Link the last slot to the first.
current.FillNextSlot(SlotList[0]);
}
public static void ReadInstalledMod()
{
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
if (asm.FullName == "Anonymously Hosted DynamicMethods Assembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")
{
continue;
}
if (asm.FullName == "HarmonySharedState, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")
{
continue;
}
if (asm.Location.IsEmpty() && asm.FullName.Contains("Eco") == false && asm.FullName.Contains("System") == false && asm.FullName.Contains("Lidgren") == false &&
asm.FullName.Contains("SharpNoise") == false && asm.FullName.Split(',').First() != "C5" && asm.FullName.Contains("NodeGraphControl") == false &&
asm.FullName.Contains("Newtonsoft") == false && asm.FullName.Contains("Priority Queue") == false && asm.FullName.Contains("NLog") == false &&
asm.FullName.Contains("Humanizer") == false && asm.FullName.Contains("LiteDB") == false && asm.FullName.Contains("LZ4") == false)
{
installedMod.Add(asm);
Console.WriteLine(" - " + asm.FullName.Split(',').First() + " " + asm.FullName.Split(',')[1].Split('=').Last());
}
}
}
/// <summary>
/// Handle received connection on the socket object.
/// </summary>
void IServerHandler.ConnectionAccepted(Socket socket)
{
Console.WriteLine($"client {socket.RemoteEndPoint} connected");
// create new chat member from received socket
var client = new ChatMember(socket);
// add the new connection to managed list
_clients.Add(client);
// register the client handler (process chat messages) to be managed in local class
client.ClientHandler = this;
// use the chat system serializer
client.SerializationHandler = ChatMessageSerializer.Instance;
// use the global pool for socket events
client.EventHandler = Program.EventManager;
// begin receving data from chat member, in a ChatMessage object that extends NetworkMessageHandler
client.ReceiveAsync <ChatMessage>();
}
/// <summary>
/// Handle received connection on the socket object.
/// </summary>
async void IServerHandler.OnSocketAccepted(Socket socket)
{
Console.WriteLine($"client {socket.RemoteEndPoint} connected");
// create new chat member from received socket
using (var client = new ChatMember(socket)) {
// add the new connection to managed list
_clients.Add(client);
// register the client handler (process chat messages) to be managed in local class
client.ClientHandler = this;
// use the chat system serializer
client.SerializationHandler = ChatMessageSerializer.Instance;
// begin receving data from chat member, in a ChatMessage object that extends NetworkMessageHandler
await client.BeginReceiveAsync <ChatMessage>();
// remove the member from managed connections
_clients.Remove(client);
}
}
/// <summary>
/// Generate possible backup file names
/// </summary>
/// <param name="path"></param>
/// <param name="fileName"></param>
/// <param name="fileExtension"></param>
/// <returns></returns>
private static ThreadSafeList <string> _MutexFileRuntime(string path, string fileName, string fileExtension)
{
var lstFiles = new ThreadSafeList <string>();
// ToDo use a list provided by the user
string[] backupExt = { "old", "bak", "back", "1", "2", "txt", "~", "save", "backup" };
string[] oldVersions = { "1", "2", "_1", "_2", "_backup" };
fileExtension = fileExtension.Trim('.');
foreach (var newFile in (from newExt in backupExt.Concat(oldVersions)
let aux = path.Split(new[] { "/" }, StringSplitOptions.None)
let realPath = string.Join("/", aux.Take(aux.Count() - 1)) + "/"
select(string.Equals(newExt, "~"))
? realPath + fileName + "." + fileExtension + newExt
: realPath + fileName + "." + fileExtension + "." + newExt).Where(
newFile => !lstFiles.Contains(newFile)))
{
lstFiles.Add(newFile);
}
return(lstFiles);
}
/// <summary>
/// Create the grid
/// </summary>
private void DrawGrid()
{
HelixGrid = null;
var newLines = new ThreadSafeList<Point3D>();
for (int x = -10; x <= 10; x++)
{
newLines.Add(new Point3D(x, -10, -.001));
newLines.Add(new Point3D(x, 10, -.001));
}
for (int y = -10; y <= 10; y++)
{
newLines.Add(new Point3D(-10, y, -.001));
newLines.Add(new Point3D(10, y, -.001));
}
HelixGrid = newLines;
}