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