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(); }