protected SyncResult DownloadAllDataForSync(DateTime lastSyncDate)
{
var resultBase = DownloadBaseData();
var standardSyncItems = Task.Run(() => ConnectorLocator.SyncConnector.GetStandardsSyncData(lastSyncDate, 0, int.MaxValue));
var topicSyncItems = Task.Run(() => ConnectorLocator.SyncConnector.GetTopicsSyncData(lastSyncDate, 0, int.MaxValue));
var syncRes = new SyncResult(resultBase)
{
StandardSyncItems = standardSyncItems.Result,
TopicSyncItems = topicSyncItems.Result
};
var standardIds = syncRes.StandardSyncItems.Select(x => x.Id);
var standardLoader = new LoaderBase <Guid, AcademicBenchmarkConnector.Models.Standard>(standardIds);
syncRes.Standards = standardLoader.Load(id => Task.Run(() => ConnectorLocator.StandardsConnector.GetStandardById(id)).Result);
var topicIds = syncRes.TopicSyncItems.Select(x => x.Id);
var topicLoader = new LoaderBase <Guid, AcademicBenchmarkConnector.Models.Topic>(topicIds);
syncRes.Topics = topicLoader.Load(id => Task.Run(() => ConnectorLocator.TopicsConnector.GetTopic(id)).Result);
Log.LogInfo("Downloaded Standard, Topic sync data");
return(syncRes);
}
void FindLoader(Scene _scene, LoadSceneMode _loadSceneMode)
{
loader = FindObjectOfType <LoaderBase>();
loader.LoadingPanel.SetActive(true);
loader.CountinueButton.SetActive(false);
loader.SetGameManager();
GameManager3D.instance.CurrentSceneIndex = GameManager3D.instance.NextSceneIndex;
SceneManager.sceneLoaded -= FindLoader;
}
static MetacallEntryPoint()
{
log.Info("CSLoader static initialization");
#if NETCOREAPP1_0 || NETCOREAPP1_1 || NETCOREAPP1_2
loader = new Providers.LoaderV1(log);
#elif NETCOREAPP2_0 || NETCOREAPP2_1 || NETCOREAPP2_2
loader = new Providers.LoaderV2(log);
#endif
}
//construction and initialization
public static ILoad Create(string path)
{
InstanceChooser myChooser = new InstanceChooser();
LoaderBase myLoader = myChooser.Choose(path);
if (myLoader != null)
{
myLoader.Load(path); //virtual method call moved out of constructor.
}
return(myLoader);
}
public AssetsLoadController(AssetsLoadType loadType)
{
this.loadType = loadType;
if (loadType == AssetsLoadType.Resources)
{
loader = new ResourcesLoader(this);
}
else
{
loader = new AssetBundleLoader(this);
}
}
public MortalFactory(int _spawnX, int _spawnY, LoaderBase[][] _cl)
{
_decorLoaders = _cl;
spawnX = _spawnX;
spawnY = _spawnY;
int ww = MainGame.Width;
int hh = MainGame.Height;
int _terrainTileWidth = (ww / 32) + MainGame.ADDONWIDTH;
int _terrainTileHeight = (hh / 32) + MainGame.ADDONHEIGHT;
_terrainTileWidth -= _terrainTileWidth % 4;
_terrainTileHeight -= _terrainTileHeight % 4;
loadData();
}
static MetacallEntryPoint()
{
log.Info("CSLoader Initialization - Runtime Version: "
+ RuntimeEnvironment.GetSystemVersion()
+ " - Language Version: "
+ LanguageVersionFacts.ToDisplayString(LanguageVersionFacts.MapSpecifiedToEffectiveVersion(LanguageVersion.Latest)));
#if NETCOREAPP1_0 || NETCOREAPP1_1 || NETCOREAPP1_2
loader = new Providers.LoaderV1(log);
#elif NETCOREAPP2_0 || NETCOREAPP2_1 || NETCOREAPP2_2 || NET5_0 // TODO: Implement or test support for 3
loader = new Providers.LoaderV2(log);
#else
# error "NET Core platform not supported"
#endif
}
private void LoadScene()
{
loader = FindObjectOfType <LoaderBase>();
loader.LoadingPanel.SetActive(true);
loader.CountinueButton.SetActive(false);
if (GameManager3D.instance.CurrentSceneIndex != GameManager3D.instance.NextSceneIndex)
{
SceneManager.sceneLoaded += FindLoader;
SceneManager.LoadScene(GameManager3D.instance.NextSceneIndex);
}
else
{
loader.SetGameManager();
}
}
private IEnumerator LoadingProcess(LoaderBase loader)
{
_core.Services.Clear();
loader.Load(_core);
var loadingAsyncOperation = SceneManager.LoadSceneAsync(loader.Path);
if (loadingAsyncOperation != null)
{
while (!loadingAsyncOperation.isDone)
{
yield return(new WaitForEndOfFrame());
}
}
_isLoading = false;
}
public Asset(string path, LoadType loadType, AssetType type)
{
this.assetPath = path;
this.type = type;
if (loadType == LoadType.Type_AssetBundle)
{
this.loader = new AssetBundleLoader();
}
else if (loadType == LoadType.Type_AppData)
{
this.loader = new AppDataLoader();
}
else if (loadType == LoadType.Type_Resources)
{
this.loader = new ResourceLoader();
}
else if (loadType == LoadType.Type_Auto)
{
if (AssetLibrary.FindDepends(path) != null)
{
this.loader = new AssetBundleLoader();
}
else
{
this.loader = new ResourceLoader();
}
}
else if (loadType == LoadType.Type_WWW)
{
this.loader = new WWWLoader();
}
if (this.loader != null)
{
this.loader.asset = this;
this.loader.Load();
}
}
/// <summary>
/// Initialize new instance of analyzing context.
/// </summary>
/// <param name="machine">Machine which uses current context</param>
/// <param name="loader">Loader that will be used for method resolving</param>
internal AnalyzingContext(Machine machine, LoaderBase loader)
{
Machine = machine;
_loader = loader;
}
public static bool LoaderExists(LoaderBase loader)
{
return _loaders.Contains(loader);
}
public static void Register(LoaderBase loader)
{
if (_loaders.Contains(loader) == false)
{
_loaders.Add(loader);
}
}
protected void FullImport()
{
Log.LogInfo("Last sync date is empty. Started full import.");
var importResult = DownloadAllDataForImport();
var dbService = (ImportDbService)ServiceLocator.DbService;
dbService.BeginTransaction();
Log.LogInfo("Started database transaction");
var pingThread = new Thread(PingConnection);
pingThread.Start(dbService);
try
{
ServiceLocator.SyncService.BeforeSync();
ProcessImportResult(importResult);
}
catch (Exception e)
{
Log.LogInfo($"Error: {e.Message}");
Log.LogInfo("Transaction is going to rollback");
dbService.Rollback();
throw;
}
finally
{
try
{
pingThread.Abort();
}
catch (Exception)
{
// ignored
}
}
ServiceLocator.SyncService.AfterSync();
dbService.CommitAll();
Log.LogInfo("Transaction was commited");
/////////////////////////////////////Proccessing Standardar Relations in another transaction////////////////////////////////////////////////////
var standardIds = importResult.Standards.Select(x => x.Id).ToList();
Log.LogInfo("Loading Standard Relations . . .");
var standardRelLoader = new LoaderBase <Guid, AcademicBenchmarkConnector.Models.StandardRelations>(standardIds);
var standardRels = standardRelLoader.Load(id => Task.Run(() => ConnectorLocator.StandardsConnector.GetStandardRelationsById(id)).Result);
dbService.BeginTransaction();
Log.LogInfo("Started database transaction");
pingThread = new Thread(PingConnection);
pingThread.Start(dbService);
try
{
var standardDerivatives = new List <StandardDerivative>();
foreach (var standardRel in standardRels)
{
standardDerivatives.AddRange(MapperHelper.Map(standardRel) ?? new List <StandardDerivative>());
}
ServiceLocator.StandardDerivativeService.Add(standardDerivatives);
}
catch (Exception e)
{
Log.LogError($"Error: {e.Message}");
Log.LogInfo("Transaction is going to rollback");
dbService.Rollback();
throw;
}
finally
{
try
{
pingThread.Abort();
}
catch (Exception)
{
// ignored
}
}
ServiceLocator.SyncService.UpdateLastSyncDate(DateTime.UtcNow.Date);
dbService.CommitAll();
Log.LogInfo("Transaction was commited.");
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
/// <summary>
/// Initializes a new instance of the <see cref="EmitDirectorLoader"/> class.
/// </summary>
/// <param name="director">The director that is used for entry method.</param>
/// <param name="wrappedLoader">The wrapped loader.</param>
internal EmitDirectorLoader(EmitDirector director, LoaderBase wrappedLoader)
{
_director = director;
_wrapped = wrappedLoader;
}
