public async Task LogException(Exception exception, int userId, int facilityId, int loginId, string pageName, string serverName)
{
try
{
using (var db = uowFactory.GetUnitOfWork())
{
var ex = new ExceptionLog()
{
UserID = userId,
FacilityID = facilityId,
Message = exception.Message,
Method = exception.TargetSite?.ToString(),
StackTrace = exception.StackTrace,
Time = DateTime.Now,
LoginID = loginId,
PageName = pageName,
ServerName = serverName
};
db.Exceptions.Add(ex);
await db.SaveChangesAsync();
}
}
catch (Exception ex)
{
throw ex;
}
}
public List <Group> GetAll(int userId)
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
return(uow.GroupRepository.GetAll().Where(g => g.OwnerId == userId).Include(group => group.Course).ToList());
}
}
public async Task <PRecord> GetPTable(string tableName, string objectId, CancellationToken cancellationToken, ISourceForScript template)
{
cancellationToken.ThrowIfCancellationRequested();
var result = new List <PRecord>();
var tableMetaData = _schema.GetTableMetaData(tableName);
var sql = string.Format("select * from {0} where [{1}] = {2}", tableName, tableMetaData.PK.FieldName, objectId);
_log.DebugFormat("GetPTable : {0}", sql);
var processed = processedTables.FirstOrDefault(_ => _.TableName == tableName && _.PK == objectId);
if (processed != null)
{
_log.DebugFormat("Object ({0}) with id {1} has been found in processedTables", processed.TableName, processed.PK);
return(processed);
}
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
var reader = await uow.ExecuteReaderAsync(sql, cancellationToken);
while (reader.Read())
{
result.Add(new PRecord(reader, tableMetaData)
{
Source = sql.Trim(), ExtractStrategy = GetExtractStrategy(tableName, template), SqlBuildStrategy = GetSqlBuildStrategy(tableName, template)
});
}
}
return(result.FirstOrDefault());
}
/// <summary>
/// Creates a new session for the given user,
/// with <paramref name="pQuestionsQuantity"/> questions from the
/// given category and level.
/// </summary>
/// <returns>The session.</returns>
/// <param name="pUserId">User identifier</param>
/// <param name="pCategoryId">Category identifier.</param>
/// <param name="pLevelId">Level identifier.</param>
/// <param name="pQuestionsQuantity">Questions quantity.</param>
public ResponseDTO <SessionDTO> NewSession(int pUserId, int pCategoryId, int pLevelId, int pQuestionsQuantity)
{
if (pQuestionsQuantity < MIN_SESSION_QUESTIONS_QUANTITY)
{
throw new BadRequestException($"Questions quantity must be greather than {MIN_SESSION_QUESTIONS_QUANTITY}");
}
using (IUnitOfWork bUoW = _unitOfWorkFactory.GetUnitOfWork())
{
var user = bUoW.UserRepository.Get(pUserId) ?? throw new NotFoundException($"User id {pUserId} not found.");
var level = bUoW.LevelRepository.Get(pLevelId) ?? throw new NotFoundException($"Level id {pLevelId} not found.");
var category = bUoW.CategoryRepository.Get(pCategoryId) ?? throw new NotFoundException($"Category id {pCategoryId} not found.");
var questions = bUoW.QuestionRepository.GetQuestions(category, level, pQuestionsQuantity).ToList();
var session = new Session
{
User = user,
Level = level,
Category = category,
Questions = questions,
Date = DateTime.Now,
Score = 0d
};
bUoW.SessionRepository.Add(session);
bUoW.Complete();
var sessionDTO = _mapper.Map <SessionDTO>(session);
return(ResponseDTO <SessionDTO> .Ok("Session successfully created.", sessionDTO));
}
}
public async Task <EnableRoleResponse> EnableRole(EnableRoleRequest request)
{
var sessionUser = await _sessionManager.GetUser();
var response = new EnableRoleResponse();
var roles = await _cache.Roles();
var role = roles.FirstOrDefault(u => u.Id == request.Id);
using (var uow = _uowFactory.GetUnitOfWork())
{
await uow.UserRepo.EnableRole(new Repositories.DatabaseRepos.UserRepo.Models.EnableRoleRequest()
{
Id = role.Id,
Updated_By = sessionUser.Id
});
uow.Commit();
}
_cache.Remove(CacheConstants.Roles);
await _sessionManager.WriteSessionLogEvent(new Models.ManagerModels.Session.CreateSessionLogEventRequest()
{
EventKey = SessionEventKeys.RoleEnabled,
Info = new Dictionary <string, string>()
{
{ "Role_Id", request.Id.ToString() }
}
});
response.Notifications.Add($"Role '{role.Name}' has been enabled", NotificationTypeEnum.Success);
return(response);
}
public async Task <IEnumerable <PDependentTable> > GetDependentTables(string tableName, CancellationToken cancellationToken)
{
var sql = sqlFKs;
if (!string.IsNullOrEmpty(tableName))
{
sql = string.Format("{0} where OBJECT_NAME(fk.parent_object_id) = '{1}' or OBJECT_NAME(fk.referenced_object_id) = '{1}'", sql, tableName);
}
var result = new List <PDependentTable>();
using (var uof = _uowFactory.GetUnitOfWork())
using (var dr = await uof.ExecuteReaderAsync(sql, cancellationToken))
{
var dt = new DataTable();
dt.Load(dr);
foreach (DataRow r in dt.Rows)
{
var item = new PDependentTable
{
Name = r["Name"].ToString(),
ParentColumn = r["ParentColumn"].ToString(),
ParentTable = r["ParentTable"].ToString(),
ReferencedColumn = r["ReferencedColumn"].ToString(),
ReferencedTable = r["ReferencedTable"].ToString()
};
result.Add(item);
}
}
return(result);
}
public async Task Init(CancellationToken cancellationToken)
{
_log.Debug("MS SQL source schema init.");
var sourceInfo = Task.Run <Tuple <string, string> >(() => {
using (var uow = _uowFactory.GetUnitOfWork())
{
return(new Tuple <string, string>(uow.Database, uow.DataSource));
}
});
_log.DebugFormat("Connected to {0}\\{1}", sourceInfo.Result.Item2, sourceInfo.Result.Item1);
_log.Debug("Getting metadata...");
var dTables = _objectMetaDataProvider.GetDependentTables(cancellationToken);
var MetaData = GetMetaData(new MetaDataInitializer(), cancellationToken);
await Task.WhenAll(dTables, MetaData, sourceInfo);
_log.Debug("Done");
_log.DebugFormat("FKs: {0}", dTables.Result.Count());
_log.DebugFormat("Tables: {0}", MetaData.Result.Count());
_dependentTables = dTables.Result;
_tables = MetaData.Result;
_database = sourceInfo.Result.Item1;
_dataSource = sourceInfo.Result.Item2;
WasInit = true;
}
public IEnumerable <ConnectionDB> GetConnectionDBs()
{
using (var unitOfWork = _unitOfWorkFactory.GetUnitOfWork())
{
return(unitOfWork.ConnectionDBs.GetMany(p => p.Delflag == DelflagConstants.ActiveSet));
}
}
public User GetUserByEmail(string email)
{
using (var unitOfWork = _unitOfWorkFactory.GetUnitOfWork())
{
return(unitOfWork.Users.GetAll().FirstOrDefault(e => e.Email.Equals(email) && e.Delflag == DelflagConstants.ActiveSet));
}
}
/// <summary>
/// Adds a new language to the database.
/// </summary>
/// <param name="language">The language to be added to the database.</param>
/// <returns>The id of a new database record, or -1, if such language already exists.</returns>
public int AddLanguage(Language language)
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
if (uow.LanguageRepository.GetAll()
.Any(l => l.Name == language.Name))
{
return(-1);
}
uow.LanguageRepository.Add(language);
uow.Save();
return(language.Id);
}
//using (var context = new WorldOfWordsDatabaseContext())
//{
// if (context
// .Languages
// .Any(l => l.Name == language.Name))
// {
// return -1;
// }
// context.Languages.Add(language);
// context.SaveChanges();
// return language.Id;
//}
}
public List <Enrollment> GetByGroupId(int groupId)
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
return(uow.EnrollmentRepository.GetAll().Where(e => e.GroupId == groupId).Include(e => e.User).OrderBy(e => e.User.Name).ToList());
}
}
public IEnumerable <Project> GetProjects()
{
using (var unitOfWork = _unitOfWorkFactory.GetUnitOfWork())
{
return(unitOfWork.Projects.GetMany(p => p.Delflag == DelflagConstants.ActiveSet));
}
}
public IEnumerable <Project> GetProjects()
{
using (var unitOfWork = _unitOfWorkFactory.GetUnitOfWork())
{
return(unitOfWork.Projects.GetMany(p => p.Delflag == DelflagConstants.ActiveSet).OrderByDescending(g => g.CreatedDate));
}
}
public async Task <RecordModel> GetRecordModelByIdAsync(int recordId)
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
var record = await uow.RecordRepository.GetByIdAsync(recordId);
return(record != null?_recordMapper.ToApiModel(record) : null);
}
}
public async Task <PictureModelToUser> GetPictureByWordIdAsync(int wordId)
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
Picture pic = await uow.PictureRepository.GetAll().FirstOrDefaultAsync(p => p.WordId == wordId);
return(pic != null?_pictureMapper.ToApiModel(pic) : null);
}
}
/// <summary>
/// Gets all Questions Sets available.
/// </summary>
/// <returns>Questions set list.</returns>
public ResponseDTO <IEnumerable <QuestionsSetDTO> > GetQuestionsSets()
{
using (IUnitOfWork bUoW = _unitOfWorkFactory.GetUnitOfWork())
{
var questionsSets = _mapper.Map <IEnumerable <QuestionsSetDTO> >(bUoW.QuestionsSetRepository.GetAll().ToList());
if (!questionsSets.Any())
{
throw new NoContentException("There are no questions sets in the database");
}
return(ResponseDTO <IEnumerable <QuestionsSetDTO> > .Ok(questionsSets));
}
}
public async Task <RegisterResponse> Register(RegisterRequest request)
{
var response = new RegisterResponse();
var username = request.EmailAddress;
var duplicateResponse = await DuplicateUserCheck(new DuplicateUserCheckRequest()
{
EmailAddress = request.EmailAddress,
Username = username
});
if (duplicateResponse.Notifications.HasErrors)
{
response.Notifications.Add(duplicateResponse.Notifications);
return(response);
}
int id;
using (var uow = _uowFactory.GetUnitOfWork())
{
id = await uow.UserRepo.CreateUser(new Repositories.DatabaseRepos.UserRepo.Models.CreateUserRequest()
{
Username = username,
Email_Address = request.EmailAddress,
Password_Hash = PasswordHelper.HashPassword(request.Password),
Is_Enabled = true,
Created_By = ApplicationConstants.SystemUserId,
});
uow.Commit();
}
_cache.Remove(CacheConstants.UserRoles);
await _sessionManager.WriteSessionLogEvent(new Models.ManagerModels.Session.CreateSessionLogEventRequest()
{
EventKey = SessionEventKeys.UserRegistered,
Info = new Dictionary <string, string>()
{
{ "Username", username }
}
});
await _emailManager.SendAccountActivation(new Models.ServiceModels.Email.SendAccountActivationRequest()
{
UserId = id
});
response.Notifications.Add($"You have been successfully registered, please check {request.EmailAddress} for a link to activate your account.", NotificationTypeEnum.Success);
return(response);
}
public IEnumerable <LanguageViewModel> GetLanguages()
{
using (var uow = _factory.GetUnitOfWork(false))
{
var languageRepository = uow.GetRepository <ILanguageRepository>();
return(languageRepository.GetLanguages().Select(o => new LanguageViewModel
{
Id = o.Id,
Name = o.Name
}).AsEnumerable());
}
}
public IEnumerable <LanguageViewModel> GetLanguages()
{
using (var uow = _factory.GetUnitOfWork())
{
var languageRepository = uow.LanguageRepository;
return(languageRepository.GetLanguages().Select(o => new LanguageViewModel
{
Id = o.Id,
Name = o.Name
}).ToArray());
}
}
public async Task <GetUsersResponse> GetUsers()
{
var response = new GetUsersResponse();
using (var uow = _uowFactory.GetUnitOfWork())
{
response.Users = await uow.UserRepo.GetUsers();
uow.Commit();
return(response);
}
}
public void CreateQuery(Query query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
using (var unitOfWork = _unitOfWorkFactory.GetUnitOfWork())
{
unitOfWork.Queries.Create(query);
unitOfWork.Save();
}
}
public bool CheckIdentity(string hashedToken, string id)
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
int userId;
if (int.TryParse(id, out userId))
{
var user = uow.UserRepository.GetById(userId);
return(hashedToken.Equals(user.HashedToken));
}
return(false);
}
}
public async Task <IEnumerable <TicketForListModel> > GetAllTicketsAsync()
{
List <Ticket> tickets;
using (var uow = unitOfWorkFactory.GetUnitOfWork())
{
tickets = await uow.TicketRepository.GetAll().Include(t => t.User).ToListAsync();
}
return(tickets.Select(t => ticketMapper.Map(t)));
}
public IPagedList <ContactDto> Search(SearchContactDto searchContactDto)
{
using (var uow = unitOfWorkFactory.GetUnitOfWork())
{
var filter = Mapper.Map <SearchContactSpecification>(searchContactDto);
//ValidateAndThrow(filter);
return(uow
.Repository
.IsSatisfiedBy(filter)
.ProjectTo <ContactDto>()
.ApplyPaging(searchContactDto.PageNumber, searchContactDto.PageSize));
}
}
public bool AddPersonToDB(IPerson person)
{
try
{
IUnitOfWork unitOfWork = _factory.GetUnitOfWork();
unitOfWork.PhoneBookRepo.Add(PhoneBookMapper.MapPerBEToDE(person));
unitOfWork.SaveChanges();
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <GetSessionResponse> GetSession()
{
var response = new GetSessionResponse();
// get or create a new session
var session = await _sessionProvider.Get <SessionEntity>(SessionConstants.SessionEntity);
if (session == null)
{
// flush any authenticated cookies in the event the application restarts
await _httpContextAccessor.HttpContext.SignOutAsync();
await _sessionProvider.Clear();
var userAgent = _httpContextAccessor.HttpContext.Request.Headers[HeaderNames.UserAgent].FirstOrDefault();
using (var uow = _uowFactory.GetUnitOfWork())
{
response.SessionEntity = await uow.SessionRepo.CreateSession(new Repositories.DatabaseRepos.SessionRepo.Models.CreateSessionRequest()
{
User_Agent = userAgent,
Created_By = ApplicationConstants.SystemUserId
});
uow.Commit();
}
await _sessionProvider.Set(SessionConstants.SessionEntity, response.SessionEntity);
return(response);
}
response.SessionEntity = session;
var sessionLogId = await _sessionProvider.Get <int?>(SessionConstants.SessionLogId);
if (sessionLogId != null)
{
response.SessionLogId = sessionLogId.Value;
}
var isDebug = await _sessionProvider.Get <bool?>(SessionConstants.IsDebug);
if (isDebug != null)
{
response.IsDebug = isDebug ?? false;
}
return(response);
}
public void AddRepresentative(Representative Representative)
{
try
{
using (var db = _unitOfWorkFactory.GetUnitOfWork())
{
db.Representatives.Add(Representative);
db.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
}
public void AddClient(Client client)
{
try
{
using (var db = _unitOfWorkFactory.GetUnitOfWork())
{
db.Clients.Add(client);
db.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
}
public void AddUser(User user)
{
try
{
using (var db = _unitOfWorkFactory.GetUnitOfWork())
{
db.Users.Add(user);
db.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task SendAccountActivation(SendAccountActivationRequest request)
{
var activationToken = string.Empty;
UserEntity user;
using (var uow = _uowFactory.GetUnitOfWork())
{
user = await uow.UserRepo.GetUserById(new Infrastructure.Repositories.UserRepo.Models.GetUserByIdRequest()
{
Id = request.UserId
});
activationToken = GenerateUniqueUserToken(uow);
await uow.UserRepo.CreateUserToken(new Infrastructure.Repositories.UserRepo.Models.CreateUserTokenRequest()
{
User_Id = request.UserId,
Token = new Guid(activationToken),
Type_Id = (int)TokenTypeEnum.AccountActivation,
Created_By = ApplicationConstants.SystemUserId,
});
uow.Commit();
}
var configuration = await _cache.Configuration();
var baseUrl = _httpContextAccessor.HttpContext.Request.GetBaseUrl();
var templates = await _cache.EmailTemplates();
var templateEntity = templates.FirstOrDefault(t => t.Key == EmailTemplateKeys.AccountActivation);
var template = new AccountActivationTemplate(templateEntity.Body)
{
ActivationUrl = $"{baseUrl}/activate-account?token={activationToken}",
ApplicationUrl = baseUrl
};
await _emailProvider.Send(new Infrastructure.Email.Models.SendRequest()
{
FromAddress = configuration.System_From_Email_Address,
ToAddress = user.Email_Address,
Subject = template.Subject,
Body = template.GetHTMLContent()
});
}
