public Version GetLatestVersion(string module = "Shell")
{
using (var uow = this.GetUnitOfWork())
{
return(!Exists(module) ? null : VersionRepository.Query(v => v.Module.Equals(module)).OrderByDescending(v => v.Date).FirstOrDefault());
}
}
public HttpResponseMessage GetData()
{
try
{
VersionsResponse versionsResponse = new VersionsResponse();
VersionsResults versionsResults = new VersionsResults();
versionsResults.appVersions = VersionRepository.GetAllVersion();
versionsResults.apiMessage = appmessage.versionSuccessfully;
if (versionsResults != null)
{
versionsResponse.status = true;
versionsResponse.message = appmessage.executedSuccessfully;
versionsResponse.results = versionsResults;
var response = this.Request.CreateResponse(HttpStatusCode.OK);
response.Content = new StringContent(JsonConvert.SerializeObject(versionsResponse, Formatting.None), Encoding.UTF8, "application/json");
return(response);
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Not found"));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
static void Main()
{
Application.SetHighDpiMode(HighDpiMode.SystemAware);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var nativeWindowManager = new NativeWindowManager();
var screenManager = new ScreenManager();
var audioManager = new AudioManager();
var versionRepository = new VersionRepository();
var settingService = new SettingService();
var debugService = new DebugService();
settingService.Init();
var isDebugMode = System.Environment.GetCommandLineArgs().Count(v => v == "--debug") == 1;
if (isDebugMode)
{
debugService.AllocConsole();
}
var _ = new Views.UmaMadoManagerUI(
new Core.ViewModels.AxisStandardViewModel(
nativeWindowManager,
screenManager,
audioManager,
versionRepository,
settingService));
Application.Run();
}
public async Task InsertMatchesFail1()
{
var fakeEvent = TestDtoHelper.CreateFakeEvent();
fakeEvent.match.map = "Maps/frozenthrone/community/(2)amazonia.w3x";
fakeEvent.match.state = 3;
var mockEvents = new Mock <IMatchEventRepository>();
mockEvents.SetupSequence(m => m.Load(It.IsAny <string>(), It.IsAny <int>()))
.ReturnsAsync(new List <MatchFinishedEvent>()
{
fakeEvent
})
.ReturnsAsync(new List <MatchFinishedEvent>());
var mockMatchRepo = new Mock <IMatchRepository>();
var versionRepository = new VersionRepository(MongoClient);
var handler = new ReadModelHandler <MatchReadModelHandler>(
mockEvents.Object,
versionRepository,
new MatchReadModelHandler(mockMatchRepo.Object));
await handler.Update();
mockMatchRepo.Verify(m => m.Insert(It.IsAny <Matchup>()), Times.Never);
}
public async Task LoadEmpty()
{
var versionRepository = new VersionRepository(MongoClient);
var version = await versionRepository.GetLastVersion <IntegrationTestBase>();
Assert.AreEqual("000000000000000000000000", version.Version);
}
public void Should_set_default_migration_group()
{
var dataClientMock = new Mock <IDataClient>();
dataClientMock.Setup(d => d.Add).Returns(new FluentAdd(dataClientMock.Object));
var rep = new VersionRepository(dataClientMock.Object, null);
Assert.Equal(VersionRepository.DEFAULT_MIGRATION_GROUP, rep.MigrationGroup);
}
public async Task LoadAndSave()
{
var versionRepository = new VersionRepository(MongoClient);
await versionRepository.SaveLastVersion <IntegrationTestBase>("123");
var version = await versionRepository.GetLastVersion <IntegrationTestBase>();
Assert.AreEqual("123", version.Version);
}
public virtual async Task RemoveAllFileAsync(Guid versionId)
{
var appVersion = await VersionRepository.GetAsync(versionId);
foreach (var versionFile in appVersion.Files)
{
await VersionBlobContainer
.DeleteAsync(VersionFile.NormalizeBlobName(appVersion.Version, versionFile.Name, versionFile.Version));
}
appVersion.RemoveAllFile();
}
public StorageManager(IRocksDbContext rocksDbContext)
{
var versionIndexer = new VersionRepository(rocksDbContext);
_versionFactory = new VersionFactory(versionIndexer.GetVersion(0));
foreach (var repository in Enum.GetValues(typeof(RepositoryType)).Cast <RepositoryType>())
{
_repositoryManagers[(uint)repository] = new RepositoryManager(
(uint)repository, rocksDbContext, _versionFactory, versionIndexer
);
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
VersionRepository.Dispose();
}
disposedValue = true;
}
}
public virtual async Task AppendFileAsync(Guid versionId, string fileSha256,
string fileName, string fileVersion,
long fileSize, string filePath = "",
FileType fileType = FileType.Stream)
{
var appVersion = await VersionRepository.GetAsync(versionId);
if (appVersion.FileExists(fileName))
{
appVersion.RemoveFile(fileName);
}
appVersion.AppendFile(fileName, fileVersion, fileSize, fileSha256, filePath, fileType);
}
public virtual async Task RemoveFileAsync(Guid versionId, string fileName)
{
var appVersion = await VersionRepository.GetAsync(versionId);
var versionFile = appVersion.FindFile(fileName);
if (versionFile != null)
{
await VersionBlobContainer
.DeleteAsync(VersionFile.NormalizeBlobName(appVersion.Version, versionFile.Name, versionFile.Version));
appVersion.RemoveFile(fileName);
}
}
public void SetUp()
{
_client = DBBuilder.GetDataClient(DataProviderNames.OracleManaged);
_versionRepository = new VersionRepository(_client);
if (_client.TableExists(VersionRepository.VERSION_TABLE_NAME))
{
_client.RemoveTable(VersionRepository.VERSION_TABLE_NAME);
}
if (_client.TableExists(VersionRepository.OLD_VERSION_TABLE_NAME))
{
_client.RemoveTable(VersionRepository.OLD_VERSION_TABLE_NAME);
}
AllMigrations = new[] { M1, M2, M3, M4, M5 }.ToList();
}
public async Task TestThatNewVersionIsUpdated()
{
var fakeEvent1 = TestDtoHelper.CreateFakeEvent();
var fakeEvent2 = TestDtoHelper.CreateFakeEvent();
var fakeEvent3 = TestDtoHelper.CreateFakeEvent();
var fakeEvent4 = TestDtoHelper.CreateFakeEvent();
var fakeEvent5 = TestDtoHelper.CreateFakeEvent();
fakeEvent1.match.season = 0;
fakeEvent1.match.startTime = 5000;
fakeEvent1.Id = ObjectId.GenerateNewId();
fakeEvent2.match.season = 0;
fakeEvent2.match.startTime = 4000;
fakeEvent2.Id = ObjectId.GenerateNewId();
fakeEvent3.match.season = 1;
fakeEvent3.match.startTime = 3000;
fakeEvent3.Id = ObjectId.GenerateNewId();
fakeEvent4.match.season = 1;
fakeEvent4.match.startTime = 2000;
fakeEvent4.match.id = "Test";
fakeEvent4.Id = ObjectId.GenerateNewId();
fakeEvent5.match.season = 0;
fakeEvent5.match.startTime = 1000;
fakeEvent5.Id = ObjectId.GenerateNewId();
await InsertMatchEvents(new List <MatchFinishedEvent> {
fakeEvent1, fakeEvent2, fakeEvent3, fakeEvent4, fakeEvent5
});
var matchRepository = new MatchRepository(MongoClient, new OngoingMatchesCache(MongoClient));
var versionRepository = new VersionRepository(MongoClient);
var handler = new ReadModelHandler <MatchReadModelHandler>(
new MatchEventRepository(MongoClient),
versionRepository,
new MatchReadModelHandler(matchRepository));
await handler.Update();
var version = await versionRepository.GetLastVersion <MatchReadModelHandler>();
var matches = await matchRepository.Load();
Assert.AreEqual(1, version.Season);
Assert.AreEqual(fakeEvent5.Id.ToString(), version.Version);
Assert.AreEqual(4, matches.Count);
Assert.AreEqual(fakeEvent4.match.id, matches[0].MatchId);
Assert.AreEqual(fakeEvent4.Id, matches[0].Id);
}
/// inheritedDoc
public override async Task UpdateVersionContentAsync(StoredFileVersion version, Stream stream)
{
if (stream == null)
{
throw new Exception($"{nameof(stream)} must not be null");
}
var blob = GetBlobClient(GetAzureFileName(version));
// update properties
version.FileSize = stream.Length;
await VersionRepository.UpdateAsync(version);
await blob.UploadAsync(stream, overwrite : true);
}
public RepositoryManager(
uint repositoryId,
IRocksDbContext dbContext,
VersionFactory versionFactory,
VersionRepository versionRepository
)
{
_repositoryId = repositoryId;
_dbContext = dbContext;
_versionFactory = versionFactory;
_versionRepository = versionRepository;
var storageContext = new NodeRepository(dbContext);
TrieMap = new TrieHashMap(storageContext, versionFactory);
LatestVersion = _versionRepository.GetVersion(_repositoryId);
}
private static void DownloadProejectVersions()
{
try
{
Log.Logger.Information("Download project versions started");
var projectImporter = ImporterFactory.GetProjectImporter();
var versionRepository = new VersionRepository();
var projectIds = _dbContext.Projects.Where(i => i.ExternalId.HasValue).Select(i => i.ExternalId.Value).ToArray();
foreach (var versions in projectIds.Select(projectId => projectImporter.GetAllProjectVersions(projectId).ToList()))
{
versionRepository.Save(versions);
}
Log.Logger.Information("Download project versions finished");
}
catch (Exception ex)
{
Log.Logger.Error(ex.Message);
}
}
public HttpResponseMessage GetVersion([FromBody] AppVersionsDto appVersion)
{
int results = 0;
try
{
CommonResponse commonResponse = new CommonResponse();
VersionResults versionResults = new VersionResults();
DataTable item = VersionRepository.GetVersion();
if (item != null)
{
int val1 = VersionValue(item.Rows[0]["AppVersion"].ToString());
int val2 = VersionValue(appVersion.AppVersion.ToString());
results = VersionItem(val1, val2);
versionResults.values = results;
versionResults.apiMessage = appmessage.versionSuccessfully;
commonResponse.status = true;
commonResponse.message = appmessage.executedSuccessfully;
commonResponse.results = versionResults;
var response = this.Request.CreateResponse(HttpStatusCode.OK);
response.Content = new StringContent(JsonConvert.SerializeObject(commonResponse, Formatting.None), Encoding.UTF8, "application/json");
return(response);
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Not found"));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// inheritedDoc
public override async Task UpdateVersionContentAsync(StoredFileVersion version, Stream stream)
{
if (stream == null)
{
throw new Exception($"{nameof(stream)} must not be null");
}
var filePath = PhysicalFilePath(version);
// delete old file
if (File.Exists(filePath))
{
File.Delete(filePath);
}
// create directory if missing
var dir = Path.GetDirectoryName(filePath);
if (string.IsNullOrWhiteSpace(dir))
{
throw new Exception($"File path is not specified. Possible reason: ({nameof(ISheshaSettings.UploadFolder)} is not specified)");
}
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
// update properties
version.FileSize = stream.Length;
await VersionRepository.UpdateAsync(version);
await using (var fs = new FileStream(filePath, FileMode.Create))
{
await stream.CopyToAsync(fs);
}
}
public DbFactory()
{
UserRepository = new UserRepository();
DesignerRepository = new DesignerRepository();
ProjectRepository = new ProjectRepository();
ModelingLanguageRepository = new ModelingLanguageRepository();
ModelingLanguageElementRepository = new ModelingLanguageElementRepository();
GameGenreRepository = new GameGenreRepository();
GameGenreElementRepository = new GameGenreElementRepository();
AssociationConfRepository = new AssociationConfRepository();
AssociationConfElementRepository = new AssociationConfElementRepository();
DesignMappingRepository = new DesignMappingRepository();
GameDesignMappingElementsRepository = new GameDesignMappingElementsRepository();
AssociationTypeRepository = new AssociationTypeRepository();
AssociationRulesRepository = new AssociationRulesRepository();
ProjectSolicitationRepository = new ProjectSolicitationRepository();
GddConfigurationRepository = new GddConfigurationRepository();
GddConfigurationElementsRepository = new GddConfigurationElementsRepository();
ProjectGddRepository = new ProjectGddRepository();
ProjectGddSectionRepository = new ProjectGddSectionRepository();
ProjectGddContentSectionRepository = new ProjectGddContentSectionRepository();
VersionRepository = new VersionRepository();
ProjectFileRepository = new ProjectFileRepository();
}
public virtual async Task <AppVersion> GetByIdAsync(Guid id)
{
return(await VersionRepository.GetAsync(id));
}
public virtual async Task <AppVersion> GetByVersionAsync(PlatformType platformType, string version)
{
return(await VersionRepository.GetByVersionAsync(platformType, version));
}
public virtual async Task <long> GetCountAsync(PlatformType platformType, string filter)
{
return(await VersionRepository.GetCountAsync(platformType, filter));
}
public virtual async Task <List <AppVersion> > GetPagedListAsync(PlatformType platformType, string filter = "", string soring = nameof(AppVersion.CreationTime), bool includeDetails = true, int skipCount = 1, int maxResultCount = 10)
{
return(await VersionRepository.GetPagedListAsync(platformType, filter, soring, includeDetails, skipCount, maxResultCount));
}
public virtual async Task CreateAsync(AppVersion version)
{
await VersionRepository.InsertAsync(version);
}
public virtual async Task UpdateAsync(AppVersion version)
{
await VersionRepository.UpdateAsync(version);
}
public virtual async Task DeleteAsync(Guid id)
{
await RemoveAllFileAsync(id);
await VersionRepository.DeleteAsync(id);
}
public PublishedProviderVersionInMemoryRepository(InMemoryCosmosRepository cosmosRepository)
{
_cosmosRepository = cosmosRepository;
_realImplementation = new VersionRepository <PublishedProviderVersion>(_cosmosRepository, new NewVersionBuilderFactory <PublishedProviderVersion>());
}
public virtual async Task <AppVersion> GetLatestAsync(PlatformType platformType)
{
return(await VersionRepository.GetLatestVersionAsync(platformType));
}
public AdminService()
{
versionRepository = new VersionRepository();
}
