// Update is called once per frame
void Update()
{
if (GlobalLogger.isLogging == true)
{
GlobalLogger.addLogData(new GlobalLogger.LogDataFormat(LogName, dataType, TransformToLog.forward));
}
}
private async Task ProcessImportFileQuery(IQueryable <ImportedFile> query)
{
// order is important for file processing
var importFiles = query.OrderByDescending(f => f.OriginalFileName.StartsWith(_fileNameMatcher.AcctStatusReportNonEcaSqlLike))
.ThenByDescending(f => f.OriginalFileName.StartsWith(_fileNameMatcher.AcctStatusReportSqlLike))
.ThenByDescending(f => f.OriginalFileName.Contains(_fileNameMatcher.SytossClientInfoSqlLike))
.ThenByDescending(f => f.FileCreateDate)
.ToList();
if (!importFiles.Any())
{
GlobalLogger.LogInfo("Job has not found new files for importing. Waiting...", GetType().Name, true);
}
else
{
foreach (var file in importFiles)
{
try
{
await TryImportFile(file);
}
catch (Exception ex)
{
file.FileState = FileState.Imported;
file.FileStatus = FileStatus.Failed;
_importJobRepository.UpdateImportedFile(file);
_importJobRepository.SaveChanges();
GlobalLogger.LogError($"Error while importing file {file?.OriginalFileName}.", ex, GetType().Name, true);
}
}
}
}
public void TestGlobalLogger()
{
var log = GlobalLogger.GetLogger("Module1");
var logbis = GlobalLogger.GetLogger("Module1");
var log1x = GlobalLogger.GetLogger("Module1x");
// Check that we get the same instance.
Assert.That(log, Is.EqualTo(logbis));
// This should work but no handler is installed.
log.Info("TEST");
// Instal a message handler.
var messages = new List <ILogMessage>();
GlobalLogger.GlobalMessageLogged += messages.Add;
// Log a simple message (disabled by default).
log.Verbose("#0");
Assert.That(messages.Count, Is.EqualTo(0));
// Activate the log for all loggers starting from Info
GlobalLogger.ActivateLog(".*", LogMessageType.Verbose);
// Log a simple message
log.Verbose("#0");
Assert.That(messages.Count, Is.EqualTo(1));
Assert.That(messages[0].Text, Is.EqualTo("#0"));
// Activate the log for Module1x starting from Debug
GlobalLogger.ActivateLog(".*x", LogMessageType.Debug);
log1x.Debug("#1");
Assert.That(messages.Count, Is.EqualTo(2));
Assert.That(messages[1].Text, Is.EqualTo("#1"));
}
static async Task Main(string[] args)
{
Environment.SetEnvironmentVariable("DOTNET_ENVIRONMENT", "Development");
var host = Host.CreateDefaultBuilder()
.ConfigureServices(x =>
{
})
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.SetMinimumLevel(LogLevel.Trace);
logging.AddZLoggerConsole(options =>
{
options.EnableStructuredLogging = true;
options.FlushRate = TimeSpan.FromSeconds(5);
});
})
.UseConsoleAppFramework <Program>(args)
.Build();
GlobalLogger.SetServiceProvider(host.Services.GetRequiredService <ILoggerFactory>(), "MyApp");
await host.RunAsync();
}
private void ScrollViewer_ScrollChanged(object sender, ScrollChangedEventArgs e)
{
if (0 == e.VerticalOffset && 0 > e.VerticalChange)
{
try
{
var TopMessage = this.Messages.First(m => m is ChatMsg);
if (null != TopMessage)
{
var TopMsg = (TopMessage as CommunicationMsg);
if (MsgStatus.Failed != TopMsg.MsgStatus)
{
var LoadedMsgs = this.m_LoadMsgService.LoadMessages(this.RoomSID, TopMsg.SendTime);
foreach (var Msg in LoadedMsgs)
{
this.Messages.Insert(0, Msg);
}
}
}
this.m_ChattingView.ScrollIntoView(TopMessage);
}
catch (NullReferenceException nullRefException)
{
GlobalLogger.Log(nullRefException.Message);
}
catch (Exception unExpectedException)
{
GlobalLogger.Log(unExpectedException.Message);
}
}
}
public UserEntity GetUserInfo(string strUserSID)
{
try
{
using (var httpClient = new HttpClient())
{
httpClient.Timeout = TimeSpan.FromSeconds(10);
dynamic parameter = new JObject();
parameter.usersid = strUserSID;
var JsonParameters = JsonConvert.SerializeObject(parameter);
var postdataString = new StringContent(JsonParameters, new UTF8Encoding(), "application/json");
var responseMessage = httpClient.PostAsync(
string.Format("{0}{1}", BeautifulTalkProtocolSet.ServerURIwithPort, BeautifulTalkProtocolSet.GetUserInfoURI),
postdataString).Result;
if (responseMessage.IsSuccessStatusCode)
{
var JUserInfo = JsonConvert.DeserializeObject(responseMessage.Content.ReadAsStringAsync().Result);
return(JsonConvert.DeserializeObject <UserEntity>(JUserInfo.ToString()));
}
}
}
catch (Exception unExpectedException)
{
GlobalLogger.Log(unExpectedException.Message);
}
return(null);
}
public void Log()
{
if (GlobalLogger.isLogging == true)
{
GlobalLogger.addLogDataOnce(new GlobalLogger.LogDataFormat(name, GlobalLogger.DataType.BOOL, isPushed));
}
}
public IEnumerable <Msg> LoadMessages(string strRoomSID, long lCriterion)
{
IList <Msg> Msgs = new List <Msg>();
try
{
if (0 == lCriterion)
{
this.LoadRecentMessages(strRoomSID, Msgs);
}
else
{
this.LoadMessagesLessThan(lCriterion, strRoomSID, Msgs);
}
}
catch (NullReferenceException nullRefException)
{
GlobalLogger.Log(nullRefException.Message);
throw nullRefException;
}
catch (Exception unExpectedException)
{
GlobalLogger.Log(unExpectedException.Message);
throw unExpectedException;
}
return(Msgs);
}
public bool AddFriend(string strMySID, string strFriendSID)
{
try
{
using (var httpClient = new HttpClient())
{
httpClient.Timeout = TimeSpan.FromSeconds(10);
dynamic parameter = new JObject();
parameter.usersid = strMySID;
parameter.friendsid = strFriendSID;
var JsonParameters = JsonConvert.SerializeObject(parameter);
var postdataString = new StringContent(JsonParameters, new UTF8Encoding(), "application/json");
var responseMessage = httpClient.PostAsync(
string.Format("{0}{1}", BeautifulTalkProtocolSet.ServerURIwithPort, BeautifulTalkProtocolSet.AddFriendURI),
postdataString).Result;
return(responseMessage.IsSuccessStatusCode);
}
}
catch (Exception unExpectedException)
{
GlobalLogger.Log(unExpectedException.Message);
return(false);
}
}
public GameEngineBase(ContentManager contentManager, IServiceRegistry services, GameSystemCollection gameSystems = null)
{
Logger = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name);
GameClockManager = new GameClockManager(PhysicsGameTime);
_targetTimeDriftAdjustmentThreshold = GameClockManager.SimulationDeltaTime.Ticks / 10; // 10% of a single sim step
Services = (ServiceRegistry)services;
Content = contentManager;
GameSystems = gameSystems ?? new GameSystemCollection(Services);
// Replacing existing IGameSystemCollection with our own
var existingGameSystems = Services.GetService <IGameSystemCollection>();
if (existingGameSystems != null)
{
Services.RemoveService <IGameSystemCollection>();
}
Services.AddOrOverwriteService <IGameSystemCollection>(GameSystems);
var networkAssetDatabase = new NetworkAssetDatabase(Content, assetFolderUrls: new[] { "Prefabs", "Scenes" });
Services.AddOrOverwriteService(networkAssetDatabase);
Services.AddOrOverwriteService(GameClockManager);
var gameSettingsService = services.GetSafeServiceAs <IGameSettingsService>();
Settings = gameSettingsService.Settings;
}
public void CollectFriends(string strUserSID, FriendCollection friends)
{
try
{
var FriendsCollection = ConnectionHelper.DB.GetCollection <FriendsEntity>("FriendsEntity");
var FindFriendsQuery = Query <FriendsEntity> .EQ(f => f.UserSID, strUserSID);
var FindedFriends = FriendsCollection.FindOne(FindFriendsQuery);
if (null != FindedFriends)
{
var UserCollection = ConnectionHelper.DB.GetCollection <UserEntity>("UserEntity");
Parallel.ForEach(FindedFriends.FriendSIDs, fSid =>
{
var FindUserQuery = Query <UserEntity> .EQ(u => u.Sid, fSid);
var FindedUser = UserCollection.FindOne(FindUserQuery);
if (null != FindedUser)
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, new ThreadStart(() =>
{
friends.Add(new Friend(FindedUser.ThumbnailPath, FindedUser.UserId, FindedUser.Sid, FindedUser.NickName, FindedUser.Comment));
}));
}
});
}
}
catch (Exception unExpectedException)
{
GlobalLogger.Log(unExpectedException.Message);
}
}
public void Log()
{
if (GlobalLogger.isLogging == true)
{
GlobalLogger.addLogDataOnce(new GlobalLogger.LogDataFormat(name, GlobalLogger.DataType.FLOAT, angle));
}
}
public AccessInformation RequestAccessInfo(string strId, string strPassword)
{
this.m_Logger.Log("RequestAccessInfo Raised", Category.Info, Priority.None);
try
{
using (var httpClient = new HttpClient())
{
httpClient.Timeout = TimeSpan.FromSeconds(10);
dynamic Parameters = new JObject();
Parameters.granttype = "password";
Parameters.applicationid = BeautifulTalkProtocolSet.ApplicationId;
Parameters.id = strId;
Parameters.password = strPassword;
var JsonParameters = JsonConvert.SerializeObject(Parameters);
var postdataString = new StringContent(JsonParameters, new UTF8Encoding(), "application/json");
var responseMessage = httpClient.PostAsync(
string.Format("{0}{1}", BeautifulTalkProtocolSet.ServerURIwithPort, BeautifulTalkProtocolSet.AccessTokenURI), postdataString).Result;
if (responseMessage.IsSuccessStatusCode)
{
var JAccessInformation = JsonConvert.DeserializeObject(responseMessage.Content.ReadAsStringAsync().Result);
return(JsonConvert.DeserializeObject <AccessInformation>(JAccessInformation.ToString()));
}
}
}
catch (Exception unExpectedException)
{
GlobalLogger.Log(unExpectedException.Message);
}
return(null);
}
static void Main(string[] args)
{
#region Initialize Server
try
{
using (ServiceHost svcHost = new ServiceHost(typeof(LibrarianService), new Uri("http://localhost:8000/RoutingAi")))
{
svcHost.AddServiceEndpoint(typeof(RoutingAI.ServiceContracts.ILibrarianService),
new BasicHttpBinding(), "Librarian");
svcHost.Open();
Console.WriteLine("Press <ENTER> to terminate...");
Console.ReadLine();
}
}
catch (HttpListenerException x)
{
GlobalLogger.SendLogMessage("Critical", MessageFlags.Fatal, "Failed to start server host: {0}", x.Message);
GlobalLogger.SendLogMessage("Critical", MessageFlags.Fatal, "Please make sure RoutingAI.Librarian is running as admin.");
}
catch (Exception x)
{
GlobalLogger.SendLogMessage("Critical", MessageFlags.Fatal, "Unexpected error: {0}", x.Message);
GlobalLogger.SendLogMessage("Critical", MessageFlags.Fatal, "Stack Dump: {0}", x.StackTrace);
}
#endregion
}
public bool ReadMessages(IList <UnReadMsg> unReadMsgs)
{
try
{
if (0 == unReadMsgs.Count)
{
return(false);
}
using (var httpClient = new HttpClient())
{
httpClient.Timeout = TimeSpan.FromSeconds(10);
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(AuthRepository.AccessInfo.TokenType, AuthRepository.AccessInfo.AccessToken);
dynamic Parameters = new JObject();
Parameters.readmsgsids = string.Join(",", unReadMsgs.Select(m => m.Sid));
Parameters.roomsid = unReadMsgs[0].RoomSid;
Parameters.fromsid = unReadMsgs[0].FromSid;
var JsonParameters = JsonConvert.SerializeObject(Parameters);
var postdataString = new StringContent(JsonParameters, new UTF8Encoding(), "application/json");
var responseMessage = httpClient.PostAsync(
string.Format("{0}{1}", BeautifulTalkProtocolSet.ServerURIwithPort, BeautifulTalkProtocolSet.ReadMsgURI),
postdataString).Result;
return(responseMessage.IsSuccessStatusCode);
}
}
catch (Exception unExpectedException)
{
GlobalLogger.Log(unExpectedException.Message);
}
return(false);
}
public RoomEntity GetRoomInfo(IList <string> arMembers)
{
try
{
using (var httpClient = new HttpClient())
{
httpClient.Timeout = TimeSpan.FromSeconds(10);
dynamic JParams = new JObject();
JParams.membersids = new JArray(arMembers).ToString();
var JsonParameters = JsonConvert.SerializeObject(JParams);
var postdataString = new StringContent(JsonParameters, new UTF8Encoding(), "application/json");
var responseMessage = httpClient.PostAsync(
string.Format("{0}{1}", BeautifulTalkProtocolSet.ServerURIwithPort, BeautifulTalkProtocolSet.GetRoomInfoURI),
postdataString).Result;
var JRoom = JsonConvert.DeserializeObject(responseMessage.Content.ReadAsStringAsync().Result);
return(JsonConvert.DeserializeObject <RoomEntity>(JRoom.ToString()));
}
}
catch (Exception unExpectedException)
{
GlobalLogger.Log(unExpectedException.Message);
}
return(null);
}
public GameStudioPreviewService(SessionViewModel session)
{
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
this.session = session;
Dispatcher = session.Dispatcher;
AssetBuilderService = session.ServiceProvider.Get <GameStudioBuilderService>();
gameSettingsProvider = session.ServiceProvider.Get <GameSettingsProviderService>();
Logger = GlobalLogger.GetLogger("Preview");
loggerDebugPage = EditorDebugTools.CreateLogDebugPage(Logger, "Preview");
previewGameSettings = GameSettingsFactory.Create();
previewGameSettings.GetOrCreate <RenderingSettings>().DefaultGraphicsProfile = GraphicsProfile.Level_11_0;
UpdateGameSettings(gameSettingsProvider.CurrentGameSettings);
previewCompileContext.SetGameSettingsAsset(previewGameSettings);
previewCompileContext.CompilationContext = typeof(PreviewCompilationContext);
previewGameThread = new Thread(SafeAction.Wrap(StrideUIThread))
{
IsBackground = true, Name = "PreviewGame Thread"
};
previewGameThread.SetApartmentState(ApartmentState.STA);
previewGameThread.Start();
// Wait for the window handle to be generated on the proper thread
initializationSignal.WaitOne();
host = new GameEngineHost(windowHandle);
session.AssetPropertiesChanged += OnAssetPropertyChanged;
gameSettingsProvider.GameSettingsChanged += OnGameSettingsChanged;
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphViewModel"/> class.
/// </summary>
/// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="GraphViewModelService"/> to use for this view model.</param>
/// <param name="type"></param>
/// <param name="rootPresenters">The root <see cref="INodePresenter"/> instances.</param>
private GraphViewModel([NotNull] IViewModelServiceProvider serviceProvider, [NotNull] Type type, [NotNull] IEnumerable <INodePresenter> rootPresenters)
: base(serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (rootPresenters == null)
{
throw new ArgumentNullException(nameof(rootPresenters));
}
GraphViewModelService = serviceProvider.TryGet <GraphViewModelService>();
if (GraphViewModelService == null)
{
throw new InvalidOperationException($"{nameof(GraphViewModel)} requires a {nameof(GraphViewModelService)} in the service provider.");
}
Logger = GlobalLogger.GetLogger(DefaultLoggerName);
if (rootPresenters == null)
{
throw new ArgumentNullException(nameof(rootNode));
}
var viewModelFactory = serviceProvider.Get <GraphViewModelService>().NodeViewModelFactory;
viewModelFactory.CreateGraph(this, type, rootPresenters);
}
public override void Serialize(ContentSerializerContext context, SerializationStream stream, Texture texture)
{
if (context.Mode == ArchiveMode.Serialize)
{
throw new NotImplementedException();
}
var assetManager = context.AssetManager;
var url = context.Url;
using (var textureData = Image.Load(stream.NativeStream))
{
try
{
texture.InitializeFrom(textureData.Description, new TextureViewDescription(), textureData.ToDataBox());
// Setup reload callback (reload from asset manager)
texture.Reload = (graphicsResource) =>
{
// TODO: Avoid loading/unloading the same data
var textureDataReloaded = assetManager.Load <Image>(url);
((Texture)graphicsResource).Recreate(textureDataReloaded.ToDataBox());
assetManager.Unload(textureDataReloaded);
};
}
catch (Exception ex)
{
GlobalLogger.GetLogger("GPUTexture").Error("Unable to load Texture {0}. See Debug for more information", ex, context.Url);
}
}
}
public MQKeySet RequestMQKeys(string strTokenType, string strAccessToken)
{
this.m_Logger.Log("RequestMQKeys Raised", Category.Info, Priority.None);
try
{
using (var httpClient = new HttpClient())
{
httpClient.Timeout = TimeSpan.FromSeconds(10);
dynamic Parameters = new JObject();
Parameters.tokentype = strTokenType;
Parameters.accesstoken = strAccessToken;
var JsonParameters = JsonConvert.SerializeObject(Parameters);
var postdataString = new StringContent(JsonParameters, new UTF8Encoding(), "application/json");
var responseMessage = httpClient.PostAsync(
string.Format("{0}{1}", BeautifulTalkProtocolSet.ServerURIwithPort, BeautifulTalkProtocolSet.GetMQInfoURI), postdataString).Result;
if (responseMessage.IsSuccessStatusCode)
{
var JMQInfo = JsonConvert.DeserializeObject(responseMessage.Content.ReadAsStringAsync().Result);
return(JsonConvert.DeserializeObject <MQKeySet>(JMQInfo.ToString()));
}
}
}
catch (Exception unExpectedException)
{
GlobalLogger.Log(unExpectedException.Message);
}
return(null);
}
public static Logger CleanContext()
{
// delete previous build data
if (Directory.Exists(BuildPath))
{
Directory.Delete(BuildPath, true);
}
// Create database directory
((FileSystemProvider)VirtualFileSystem.ApplicationData).ChangeBasePath(BuildPath);
VirtualFileSystem.CreateDirectory(VirtualFileSystem.ApplicationDatabasePath);
// Delete source folder if exists
if (Directory.Exists(FileSourceFolder))
{
Directory.Delete(FileSourceFolder, true);
}
Builder.CloseObjectDatabase();
TestCommand.ResetCounter();
if (!loggerHandled)
{
GlobalLogger.GlobalMessageLogged += new ConsoleLogListener();
loggerHandled = true;
}
return(GlobalLogger.GetLogger("UnitTest"));
}
static async Task Main(string[] args)
{
Environment.SetEnvironmentVariable("DOTNET_ENVIRONMENT", "Development");
var host = Host.CreateDefaultBuilder()
.ConfigureServices(x =>
{
})
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.SetMinimumLevel(LogLevel.Trace);
logging.AddZLoggerConsole(options =>
{
options.EnableStructuredLogging = false;
//options.FlushRate = TimeSpan.FromSeconds(5);
#if DEBUG
// \u001b[31m => Red(ANSI Escape Code)
// \u001b[0m => Reset
// \u001b[38;5;***m => 256 Colors(08 is Gray)
options.PrefixFormatter = (writer, info) =>
{
if (info.LogLevel == LogLevel.Error)
{
ZString.Utf8Format(writer, "\u001b[31m[{0}]", info.LogLevel);
}
else
{
if (!info.CategoryName.StartsWith("MyApp")) // your application namespace.
{
ZString.Utf8Format(writer, "\u001b[38;5;08m[{0}]", info.LogLevel);
}
else
{
ZString.Utf8Format(writer, "[{0}]", info.LogLevel);
}
}
};
options.SuffixFormatter = (writer, info) =>
{
if (info.LogLevel == LogLevel.Error || !info.CategoryName.StartsWith("MyApp"))
{
ZString.Utf8Format(writer, "\u001b[0m", "");
}
};
#endif
}, configureEnableAnsiEscapeCode: true);
})
.UseConsoleAppFramework <Program>(args)
.Build();
GlobalLogger.SetServiceProvider(host.Services.GetRequiredService <ILoggerFactory>(), "MyApp");
await host.RunAsync();
}
private void ExecuteAddFriendCommand(string strRecommendUserSid)
{
if (true == string.IsNullOrEmpty(strRecommendUserSid))
{
return;
}
Task.Run(() =>
{
var TargetFriend = this.m_RecommendFriends.FirstOrDefault(r => r.UserSID == strRecommendUserSid);
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, new ThreadStart(() =>
{
RecommendFriends.Remove(TargetFriend);
}));
if (true == this.m_AddFriendService.AddFriend(AuthRepository.MQKeyInfo.UserSid, strRecommendUserSid))
{
try
{
var AddFriend = this.m_GetUserInfoService.GetUserInfo(strRecommendUserSid);
if (null != AddFriend)
{
var UserCollection = ConnectionHelper.DB.GetCollection <UserEntity>("UserEntity");
var FindUserQuery = Query <UserEntity> .EQ(u => u.Sid, strRecommendUserSid);
var FindedUser = UserCollection.FindOne(FindUserQuery);
if (null == FindedUser)
{
UserCollection.Save(AddFriend);
}
}
var FindFriendQuery = Query <FriendsEntity> .EQ(u => u.UserSID, AuthRepository.MQKeyInfo.UserSid);
var FriendsCollection = ConnectionHelper.DB.GetCollection <FriendsEntity>("FriendsEntity");
var FindedFriend = FriendsCollection.FindOne(FindFriendQuery);
if (null != FindedFriend)
{
if (false == FindedFriend.FriendSIDs.Contains(strRecommendUserSid))
{
FindedFriend.FriendSIDs.Add(strRecommendUserSid);
var UpdateQuery = Update <FriendsEntity> .Set(f => f.FriendSIDs, FindedFriend.FriendSIDs);
FriendsCollection.Update(FindFriendQuery, UpdateQuery);
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, new ThreadStart(() =>
{
this.m_FriendsMainViewModel.Friends.Add(new Friend(AddFriend.ThumbnailPath, AddFriend.UserId, AddFriend.Sid, AddFriend.NickName, AddFriend.Comment));
}));
}
}
}
catch (Exception unExpectedException)
{
GlobalLogger.Log(unExpectedException.Message);
}
}
});
}
public void Log()
{
//Logging system
if (GlobalLogger.isLogging == true)
{
GlobalLogger.addLogDataOnce(new GlobalLogger.LogDataFormat(name, GlobalLogger.DataType.VEC3, value));
}
}
public void Log()
{
if (GlobalLogger.isLogging == true)
{
GlobalLogger.addLogDataOnce(new GlobalLogger.LogDataFormat(name + "_gear", GlobalLogger.DataType.INT, gear));
GlobalLogger.addLogDataOnce(new GlobalLogger.LogDataFormat(name + "_angle", GlobalLogger.DataType.FLOAT, angle));
}
}
public void TestBasicPackageCreateSaveLoad()
{
// Override search path since we are in a unit test directory
DirectoryHelper.PackageDirectoryOverride = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\..");
var defaultPackage = PackageStore.Instance.DefaultPackage;
PackageArchive.Build(GlobalLogger.GetLogger("PackageArchiveTest"), defaultPackage, AppDomain.CurrentDomain.BaseDirectory);
}
public void TestRuntime()
{
var package = new Package();
// ReSharper disable once UnusedVariable - we need a package session to compile
var packageSession = new PackageSession(package);
var otherAssets = new List <AssetItem>
{
new AssetItem("asset11", new MyAsset11(), package),
new AssetItem("asset12", new MyAsset12(), package),
new AssetItem("asset13", new MyAsset13(), package),
};
otherAssets.ForEach(x => package.Assets.Add(x));
var compileAssetReference = new MyAsset4
{
CompileAssetReference = CreateRef <MyContent11>(otherAssets[0]),
CompileContentReference = CreateRef <MyContent12>(otherAssets[1]),
CompileRuntimeReference = CreateRef <MyContent13>(otherAssets[2]),
};
var assetItem = new AssetItem("asset4", compileAssetReference, package);
package.Assets.Add(assetItem);
var asset = new MyAsset1 {
CompileAssetReference = CreateRef <MyContent2>(assetItem)
};
assetItem = new AssetItem("asset1", asset, package);
package.Assets.Add(assetItem);
package.RootAssets.Add(new AssetReference(assetItem.Id, assetItem.Location));
// Create context
var context = new AssetCompilerContext {
CompilationContext = typeof(AssetCompilationContext)
};
// Builds the project
Exception ex = null;
MyAsset1Compiler.AssertFunc = (url, ass, pkg) =>
{
AssertInThread(ref ex, () => Assert.AreEqual(1, TestCompilerBase.CompiledAssets.Count));
AssertInThread(ref ex, () => Assert.AreEqual(compileAssetReference.Id, TestCompilerBase.CompiledAssets.First().Id));
};
var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package));
var assetBuildResult = assetBuilder.Prepare(context);
// Since MyAsset4 is a Runtime reference, it should be compiled, so we should have 2 asset (MyAsset1 and MyAsset4) to compile.
Assert.AreEqual(2, assetBuildResult.BuildSteps.Count);
var builder = new Builder(GlobalLogger.GetLogger("Test"), "", "", "");
builder.Root.Add(assetBuildResult.BuildSteps);
builder.Run(Builder.Mode.Build, false);
RethrowAssertsFromThread(ex);
}
public void TestCompileAsset()
{
var package = new Package();
// ReSharper disable once UnusedVariable - we need a package session to compile
var packageSession = new PackageSession(package);
var otherAssets = new List <AssetItem>
{
new AssetItem("asset5", new MyAsset5(), package),
new AssetItem("asset6", new MyAsset6(), package),
new AssetItem("asset7", new MyAsset7(), package),
};
otherAssets.ForEach(x => package.Assets.Add(x));
var compileAssetReference = new MyAsset2
{
CompileAssetReference = CreateRef <MyContent5>(otherAssets[0]),
CompileContentReference = CreateRef <MyContent6>(otherAssets[1]),
CompileRuntimeReference = CreateRef <MyContent7>(otherAssets[2]),
};
var assetItem = new AssetItem("asset2", compileAssetReference, package);
package.Assets.Add(assetItem);
var asset = new MyAsset1 {
CompileAssetReference = CreateRef <MyContent2>(assetItem)
};
assetItem = new AssetItem("asset1", asset, package);
package.Assets.Add(assetItem);
package.RootAssets.Add(new AssetReference(assetItem.Id, assetItem.Location));
// Create context
var context = new AssetCompilerContext {
CompilationContext = typeof(AssetCompilationContext)
};
// Builds the project
Exception ex = null;
MyAsset1Compiler.AssertFunc = (url, ass, pkg) =>
{
// Nothing must have been compiled before
AssertInThread(ref ex, () => Assert.Empty(TestCompilerBase.CompiledAssets));
};
var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package));
var assetBuildResult = assetBuilder.Prepare(context);
// Since MyAsset2 is a CompileAsset reference, it should not be compiled, so we should have only 1 asset (MyAsset1) to compile.
Assert.Equal(1, assetBuildResult.BuildSteps.Count);
var builder = new Builder(GlobalLogger.GetLogger("Test"), "", "");
builder.Root.Add(assetBuildResult.BuildSteps);
builder.Run(Builder.Mode.Build, false);
RethrowAssertsFromThread(ex);
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphViewModel"/> class.
/// </summary>
/// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="GraphViewModelService"/> to use for this view model.</param>
private GraphViewModel(IViewModelServiceProvider serviceProvider)
: base(serviceProvider)
{
GraphViewModelService = serviceProvider.TryGet <GraphViewModelService>();
if (GraphViewModelService == null)
{
throw new InvalidOperationException($"{nameof(GraphViewModel)} requires a {nameof(GraphViewModelService)} in the service provider.");
}
Logger = GlobalLogger.GetLogger(DefaultLoggerName);
}
private void RegisterLog()
{
var globalLogger = new GlobalLogger();
globalLogger.RegisterLogger(_exectueLogDict);
var hubClientLogger = new Loggers.HubClientLogger();
hubClientLogger.RegisterLogger(_exectueLogDict);
}
