public async Task UpdateDirectory(params UpdateDirectoryModel[] directories) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { foreach (var directory in directories) { var dirInDb = await unitOfWork.Directories.GetById(directory.Id); if (!string.IsNullOrWhiteSpace(directory.Name)) { dirInDb.Name = directory.Name; } dirInDb.Restricted = directory.Restricted; // Cannot move root directories or remove parent from child directories if (dirInDb.ParentId != null && directory.ParentId != null) { dirInDb.ParentId = directory.ParentId; } await unitOfWork.Directories.Update(dirInDb); } await unitOfWork.SaveChangesAsync(); } }
public async Task <IEnumerable <int> > GetPermissionValuesByUser(Guid userId) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var rolePermissions = (await unitOfWork.UserRoles.GetByUser(userId)).ToList(); BitArray userPermissions = null; foreach (var role in rolePermissions) { var permissions = new BitArray(role.Role.Permissions); userPermissions = userPermissions == null ? permissions : userPermissions.And(permissions); } var permIndexes = Enumerable.Range(0, Enum.GetNames(typeof(PermissionValue)).Length); List <int> permissionValues = new List <int>(); if (userPermissions != null) { foreach (var permIndex in permIndexes) { if (userPermissions[permIndex]) { permissionValues.Add(permIndex); } } } return(permissionValues); } }
public async Task CreateAchievement(Guid userId, params CreateAchievementModel[] requests) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { foreach (var request in requests) { await AcademicHelper.IsAcademicYearLocked(request.AcademicYearId, true); var model = new Achievement { AcademicYearId = request.AcademicYearId, AchievementTypeId = request.AchievementTypeId, LocationId = request.LocationId, StudentId = request.StudentId, Comments = request.Comments, OutcomeId = request.OutcomeId, Points = request.Points, CreatedById = userId, CreatedDate = DateTime.Now }; unitOfWork.Achievements.Create(model); } await unitOfWork.SaveChangesAsync(); } }
public async Task Update(params UpdateTaskModel[] tasks) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { foreach (var task in tasks) { ValidationHelper.ValidateModel(task); var taskInDb = await unitOfWork.Tasks.GetById(task.Id); if (taskInDb == null) { throw new NotFoundException("Task not found."); } if (taskInDb.System) { throw new LogicException("Tasks of this type cannot be updated manually."); } taskInDb.Title = task.Title; taskInDb.Description = task.Description; taskInDb.DueDate = task.DueDate; taskInDb.TypeId = task.TypeId; await unitOfWork.Tasks.Update(taskInDb); } await unitOfWork.SaveChangesAsync(); } }
public async Task Update(params UpdateStudentModel[] models) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { foreach (var model in models) { var student = await unitOfWork.Students.GetById(model.Id); student.DateStarting = model.DateStarting; student.DateLeaving = model.DateLeaving; student.SenStatusId = model.SenStatusId; student.SenTypeId = model.SenTypeId; student.EnrolmentStatusId = model.EnrolmentStatusId; student.BoarderStatusId = model.BoarderStatusId; student.PupilPremium = model.PupilPremium; student.Upn = model.Upn; PersonHelper.UpdatePerson(student.Person, model); await unitOfWork.People.Update(student.Person); await unitOfWork.Students.Update(student); } await unitOfWork.SaveChangesAsync(); } }
public TelegramService( ILogger <TelegramService> logger, ITelegramBotClient telegramBot, DataConnectionFactory dbFactory) { _telegramBot = telegramBot; _dbFactory = dbFactory; _logger = logger; }
public async Task CreateDirectory(params CreateDirectoryModel[] directories) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { foreach (var directory in directories) { var parentDirectory = await unitOfWork.Directories.GetById(directory.ParentId); if (parentDirectory == null) { throw new NotFoundException("Parent directory not found."); } var dirToAdd = new Directory { ParentId = directory.ParentId, Name = directory.Name, Restricted = directory.Restricted }; unitOfWork.Directories.Create(dirToAdd); } await unitOfWork.SaveChangesAsync(); } }
public async Task Create(Guid userId, params CreateLogNoteModel[] logNoteObjects) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { foreach (var logNoteObject in logNoteObjects) { await AcademicHelper.IsAcademicYearLocked(logNoteObject.AcademicYearId, true); var createDate = DateTime.Now; var logNote = new LogNote { TypeId = logNoteObject.TypeId, Message = logNoteObject.Message, StudentId = logNoteObject.StudentId, CreatedDate = createDate, CreatedById = userId, AcademicYearId = logNoteObject.AcademicYearId }; unitOfWork.LogNotes.Create(logNote); } await unitOfWork.SaveChangesAsync(); } }
public async Task Update(params UpdateLogNoteModel[] logNoteObjects) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { foreach (var logNoteObject in logNoteObjects) { var logNote = await unitOfWork.LogNotes.GetById(logNoteObject.Id); await AcademicHelper.IsAcademicYearLocked(logNote.AcademicYearId, true); var updateDate = DateTime.Now; if (logNote == null) { throw new NotFoundException("Log note not found."); } logNote.TypeId = logNoteObject.TypeId; logNote.Message = logNoteObject.Message; await unitOfWork.LogNotes.Update(logNote); } await unitOfWork.SaveChangesAsync(); } }
public async Task MyIdShouldReturnId() { // Arrange // var telegramBotMock = new Mock <ITelegramBotClient>(); telegramBotMock.Setup(_ => _.SendTextMessageAsync( It.IsAny <ChatId>(), It.IsAny <string>(), It.IsAny <ParseMode>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <int>(), It.IsAny <IReplyMarkup>(), It.IsAny <CancellationToken>())) .ReturnsAsync(new Message()) .Verifiable(); var dcFactory = new DataConnectionFactory(_connectionSettings); var telegramService = new TelegramService( TestHelper.GetLoggerMock <TelegramService>().Object, telegramBotMock.Object, dcFactory); _mockMessage.Text = "/myid"; var publicUserId = shortid.ShortId.Generate(); var yasUser = new YasUser { TelegramId = 0, PublicId = publicUserId, UserName = "******" }; await using var dc = dcFactory.Create(); { dc.GetTable <YasUser>().DataContext.InsertWithIdentity(yasUser); } // Act // await telegramService.OnBotMessage(_mockMessage); // Assert // telegramBotMock.Verify(_ => _.SendTextMessageAsync( It.IsAny <ChatId>(), It.Is <string>(m => m.Equals($"{publicUserId}")), It.IsAny <ParseMode>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <int>(), It.IsAny <IReplyMarkup>(), It.IsAny <CancellationToken>())); long usersCount; await using var dc2 = dcFactory.Create(); { usersCount = await dc2.GetTable <YasUser>().CountAsync(); } Assert.Equal(1, usersCount); }
public async Task UpdateAchievement(params UpdateAchievementModel[] requests) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { foreach (var request in requests) { var achievementInDb = await unitOfWork.Achievements.GetById(request.Id); if (achievementInDb == null) { throw new NotFoundException("Achievement not found."); } await AcademicHelper.IsAcademicYearLocked(achievementInDb.AcademicYearId, true); achievementInDb.AchievementTypeId = request.AchievementTypeId; achievementInDb.LocationId = request.LocationId; achievementInDb.OutcomeId = request.OutcomeId; achievementInDb.Comments = request.Comments; achievementInDb.Points = request.Points; await unitOfWork.Achievements.Update(achievementInDb); } await unitOfWork.SaveChangesAsync(); } }
public async Task <AcademicYearModel> GetCurrentAcademicYear(bool getLatestIfNull = false) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var acadYear = await unitOfWork.AcademicYears.GetCurrent(); if (acadYear == null) { if (getLatestIfNull) { acadYear = await unitOfWork.AcademicYears.GetLatest(); if (acadYear == null) { throw new NotFoundException("No academic years are defined."); } } else { throw new NotFoundException("There is no academic year defined for the current date."); } } return(new AcademicYearModel(acadYear)); } }
public async Task <bool> IsAcademicYearLocked(Guid academicYearId) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { return(await unitOfWork.AcademicYears.IsLocked(academicYearId)); } }
public async Task UploadFileToDocument(UploadAttachmentModel upload) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var document = await unitOfWork.Documents.GetById(upload.DocumentId); if (document == null) { throw new NotFoundException("Document not found."); } if (document.FileId.HasValue) { throw new LogicException("A file is already attached to this document."); } var file = await _fileProvider.SaveFile(upload); document.Attachment = file; await unitOfWork.Documents.Update(document); await unitOfWork.SaveChangesAsync(); } }
public async Task <StudentStatsModel> GetStatsById(Guid studentId, Guid academicYearId) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var stats = new StudentStatsModel(); var achievements = await unitOfWork.Achievements.GetPointsByStudent(studentId, academicYearId); var incidents = await unitOfWork.Incidents.GetPointsByStudent(studentId, academicYearId); var attendanceMarks = await unitOfWork.AttendanceMarks.GetByStudent(studentId, academicYearId); var exclusions = await unitOfWork.Exclusions.GetCountByStudent(studentId); var attendanceCodes = await unitOfWork.AttendanceCodes.GetAll(); var attendanceSummary = new AttendanceSummary(attendanceCodes.Select(c => new AttendanceCodeModel(c)).ToList(), attendanceMarks.Select(m => new AttendanceMarkModel(m)).ToList()); stats.StudentId = studentId; stats.AchievementPoints = achievements; stats.BehaviourPoints = incidents; stats.PercentageAttendance = attendanceSummary.GetPresentAndAea(true); stats.Exclusions = exclusions; return(stats); } }
public async Task CreateIncident(Guid userId, params CreateIncidentModel[] incidents) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { foreach (var incidentModel in incidents) { var incident = new Incident { Points = incidentModel.Points, CreatedDate = DateTime.Now, BehaviourTypeId = incidentModel.BehaviourTypeId, LocationId = incidentModel.LocationId, OutcomeId = incidentModel.OutcomeId, StatusId = incidentModel.StatusId, CreatedById = userId, StudentId = incidentModel.StudentId, Comments = incidentModel.Comments, AcademicYearId = incidentModel.AcademicYearId }; unitOfWork.Incidents.Create(incident); } await unitOfWork.SaveChangesAsync(); } }
public async Task <bool> IsTaskOwner(Guid taskId, Guid userId) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var task = await unitOfWork.Tasks.GetById(taskId); if (task == null) { throw new NotFoundException("Task not found."); } if (task.AssignedById == userId) { return(true); } var person = await unitOfWork.People.GetByUserId(userId); if (person != null && task.AssignedToId == person.Id) { return(true); } return(false); } }
public async Task SaveDbShouldCorrectlyGetDataFromQuery() { // Arrange // var connectionSettings = _factory.Services.GetRequiredService <IConnectionSettings>(); var dbConnection = new DataConnectionFactory(connectionSettings.GetDataProvider(), connectionSettings.BuildConnectionString()) .Create(); var dataProvider = new PostgresDataProvider( TestHelper.GetLoggerMock <PostgresDataProvider>().Object, new DataConnectionFactory(connectionSettings), MapperConfig.CreateMapper(), null); var watchRequest = new WatchRequest { DeviceId = "device-id", DeviceName = "device-name", Version = "version", CiqVersion = "ciq-version", Framework = "framework", WeatherProvider = "weather-provider", DarkskyKey = "dark-key", Lat = (decimal)1.1, Lon = (decimal)2.2, BaseCurrency = "USD", TargetCurrency = "EUR" }; // Act // await dataProvider.SaveRequestInfo(watchRequest, new WeatherInfo { WindSpeed = (decimal)5.5, Temperature = (decimal)4.4 }, new LocationInfo { CityName = "city-name" }, new ExchangeRateInfo { ExchangeRate = (decimal)3.3 }); // Assert // var actualDevice = await dbConnection.GetTable <DeviceData>().SingleAsync(d => d.DeviceId == watchRequest.DeviceId); var actualRequest = await dbConnection.GetTable <RequestData>().SingleAsync(r => r.DeviceDataId == actualDevice.Id); Assert.Equal("device-name", actualDevice.DeviceName); Assert.Equal("device-id", actualDevice.DeviceId); Assert.Equal(watchRequest.Framework, actualRequest.Framework); Assert.Equal(watchRequest.CiqVersion, actualRequest.CiqVersion); Assert.Equal(watchRequest.Version, actualRequest.Version); Assert.Equal(watchRequest.Lon, actualRequest.Lon); Assert.Equal(watchRequest.Lat, actualRequest.Lat); Assert.Equal(watchRequest.BaseCurrency, actualRequest.BaseCurrency); Assert.Equal(watchRequest.TargetCurrency, actualRequest.TargetCurrency); Assert.Equal((decimal)4.4, actualRequest.Temperature); Assert.Equal("city-name", actualRequest.CityName); Assert.Equal((decimal)3.3, actualRequest.ExchangeRate); }
public CreateDatabaseSchemataCommand(IMetadataProvider metadataProvider, DataConnectionFactory dataConnectionFactory, IContextEntityTypesProvider contextEntityTypesProvider) : base(metadataProvider) { _dataConnectionFactory = dataConnectionFactory; _contextEntityTypesProvider = contextEntityTypesProvider; }
public PostgresDataProvider( ILogger <PostgresDataProvider> logger, DataConnectionFactory connectionFactory, IMapper mapper, IMetrics metrics) { _logger = logger; _connectionFactory = connectionFactory; _mapper = mapper; _metrics = metrics; }
public async Task RouteListShouldReturnList() { // Arrange // var telegramBotMock = new Mock <ITelegramBotClient>(); telegramBotMock.Setup(_ => _.SendTextMessageAsync( It.IsAny <ChatId>(), It.IsAny <string>(), It.IsAny <ParseMode>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <int>(), It.IsAny <IReplyMarkup>(), It.IsAny <CancellationToken>())) .ReturnsAsync(new Message()) .Verifiable(); var dcFactory = new DataConnectionFactory(_connectionSettings); var telegramService = new TelegramService( TestHelper.GetLoggerMock <TelegramService>().Object, telegramBotMock.Object, dcFactory); _mockMessage.Text = "/list"; var publicUserId = shortid.ShortId.Generate(); var yasUser = new YasUser { TelegramId = 0, PublicId = publicUserId, UserName = "******" }; var yasRoute = new YasRoute { RouteName = "route1" }; await using var dc = dcFactory.Create(); { var userId = await dc.GetTable <YasUser>().DataContext.InsertWithInt64IdentityAsync(yasUser); yasRoute.UserId = userId; dc.GetTable <YasRoute>().DataContext.InsertWithIdentity(yasRoute); } // Act // await telegramService.OnBotMessage(_mockMessage); // Assert // telegramBotMock.Verify(_ => _.SendTextMessageAsync( It.IsAny <ChatId>(), It.Is <string>(m => m.StartsWith("<b> 1 </b> : <code>route1")), It.IsAny <ParseMode>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <int>(), It.IsAny <IReplyMarkup>(), It.IsAny <CancellationToken>())); }
public async Task <int> GetAchievementCountByStudent(Guid studentId, Guid academicYearId) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var count = await unitOfWork.Achievements.GetCountByStudent(studentId, academicYearId); return(count); } }
public async Task <int> GetBehaviourPointsByStudent(Guid studentId, Guid academicYearId) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var points = await unitOfWork.Incidents.GetPointsByStudent(studentId, academicYearId); return(points); } }
public async Task <DetentionModel> GetByIncident(Guid incidentId) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var detention = await unitOfWork.Detentions.GetByIncident(incidentId); return(new DetentionModel(detention)); } }
public async Task <AchievementModel> GetAchievementById(Guid achievementId) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var achievement = await unitOfWork.Achievements.GetById(achievementId); return(new AchievementModel(achievement)); } }
public async Task <IEnumerable <DetentionModel> > Get(DetentionSearchOptions searchOptions) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var detentions = await unitOfWork.Detentions.GetAll(searchOptions); return(detentions.Select(d => new DetentionModel(d))); } }
public async Task <IEnumerable <BehaviourStatusModel> > GetBehaviourStatus() { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var status = await unitOfWork.BehaviourStatus.GetAll(); return(status.Select(s => new BehaviourStatusModel(s)).ToList()); } }
public async Task <IEnumerable <BehaviourOutcomeModel> > GetIncidentOutcomes() { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var outcomes = await unitOfWork.BehaviourOutcomes.GetAll(); return(outcomes.Select(o => new BehaviourOutcomeModel(o)).ToList()); } }
public async Task <IEnumerable <IncidentTypeModel> > GetIncidentTypes() { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var types = await unitOfWork.IncidentTypes.GetAll(); return(types.Select(t => new IncidentTypeModel(t)).ToList()); } }
public async Task <IEnumerable <AchievementModel> > GetAchievementsByStudent(Guid studentId, Guid academicYearId) { using (var unitOfWork = await DataConnectionFactory.CreateUnitOfWork()) { var achievements = await unitOfWork.Achievements.GetByStudent(studentId, academicYearId); return(achievements.Select(a => new AchievementModel(a)).ToList()); } }