private async Task <int> MigratePractices()
{
List <Practice> records = sqlDataContext.Practices.ToList();
PracticeRepository repository = new PracticeRepository();
int recCount = 0;
try
{
postgressDataContext = new Agilisium.TalentManager.PostgresModel.TalentManagerDataContext();
// delete all existing records from Postgres Database
postgressDataContext.Practices.RemoveRange(postgressDataContext.Practices);
await postgressDataContext.SaveChangesAsync();
// Migrage SQL Server data into Postgress database
foreach (Practice rec in records)
{
postgressDataContext.Practices.Add(rec);
}
await postgressDataContext.SaveChangesAsync();
//await UpdatePractices();
recCount = records.Count;
}
catch (Exception exp)
{
MessageBox.Show($"Error while migrating PODs. The error is {Environment.NewLine}Main Exception: {exp.Message}{Environment.NewLine}Inner Exception: {exp.InnerException?.Message}");
}
return(recCount);
}
public ApplicationRepository()
{
_ctx = new ApplicationDbContext();
_userManager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(_ctx));
RefreshTokens = new RefreshTokenRepository(_ctx);
Clients = new ClientRepository(_ctx);
Exercise = new ExerciseRepository(_ctx);
Schedules = new ScheduleRepository(_ctx);
Practices = new PracticeRepository(_ctx);
}
public ManagementNotificationsProcessor()
{
allocationService = new AllocationRepository();
empService = new EmployeeRepository();
projectRepository = new ProjectRepository();
practiceRepository = new PracticeRepository();
settingRepository = new SystemSettingRepository();
logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
log4net.Config.XmlConfigurator.Configure();
}
public void ChangeNameRepoPhase()
{
var mockPracticeRepository = new Mock <IPracticeRepository>();
var repo = new PracticeRepository(mockPracticeRepository.Object);
mockPracticeRepository
.Setup(a => a.ChangeName("Norbi", "Gyula"))
.Returns("Gyula");
Assert.AreEqual("Gyula", repo.ChangeName("Norbi", "Gyula"));
}
public UnitOfWork()
{
_context = new ApplicationDbContext();
Projects = new ProjectRepository(_context);
Practices = new PracticeRepository(_context);
Users = new UserRepository(_context);
PracticeUsers = new PracticeUserRepository(_context);
Features = new FeatureRepository(_context);
FeatureUsers = new FeatureUserRepository(_context);
Experiences = new ExperienceRepository(_context);
Communications = new CommunicationRespository(_context);
Countries = new CountryRepository(_context);
}
public void should_Read_Staff()
{
var practice = new PracticeRepository(_context).GetByCode("14080");
var users = _staffService.ReadStaff().ToList();
Assert.IsTrue(users.Count > 0);
Console.WriteLine(practice);
foreach (var user in users)
{
Console.WriteLine($" >.{user}");
}
}
public UnitOfWork()
{
_context = new ApplicationDbContext();
Projects = new ProjectRepository(_context);
Practices = new PracticeRepository(_context);
Users = new UserRepository(_context);
PracticeUsers = new PracticeUserRepository(_context);
Features = new FeatureRepository(_context);
FeatureUsers = new FeatureUserRepository(_context);
Experiences = new ExperienceRepository(_context);
Communications = new CommunicationRespository(_context);
Countries = new CountryRepository(_context);
}
public void should_Enroll_Device_Site()
{
var p1 = Practice.Enroll(Guid.NewGuid(), "1", "Fac1");
var p2 = Practice.Enroll(Guid.NewGuid(), "2", "Fac2");
var practices = new List <Practice> {
p1, p2
};
_activationService.EnrollDevicePractice(practices);
var ids = practices.Select(x => x.Id);
var pr = new PracticeRepository(_context);
var ps = pr.GetAll().Where(x => ids.Contains(x.Id)).ToList();
Assert.True(ps.Count == 2);
}
public AllocationsUpdaterServiceProcessor()
{
logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
log4net.Config.XmlConfigurator.Configure();
allocationRepo = new AllocationRepository();
employeeRepo = new EmployeeRepository();
projectRepo = new ProjectRepository();
trackerRepo = new NotificationsTrackerRepository();
practiceRepository = new PracticeRepository();
settingRepository = new SystemSettingRepository();
emailClientIP = ProcessorHelper.GetSettingsValue(ProcessorHelper.EMAIL_PROXY_SERVER);
ownerEmailID = ProcessorHelper.GetSettingsValue(ProcessorHelper.CONTRACTOR_REQ_EMAIL_OWNER);
outlookPwd = ProcessorHelper.GetSettingsValue(ProcessorHelper.EMAIL_OWNERS_PASSWORD);
}
public void SetUp()
{
var config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var connectionString = config["connectionStrings:realConnection"];
var options = new DbContextOptionsBuilder <LiveHAPIContext>()
.UseSqlServer(connectionString)
.Options;
_context = new LiveHAPIContext(options);
// TestDataCreator.Init(_context);
var pr = new PracticeRepository(_context);
_practice = pr.GetAll().First();
_activationService = new ActivationService(new PracticeRepository(_context), new PracticeActivationRepository(_context), new MasterFacilityRepository(_context));
}
void IUnitOfWork.InitializeRepositories()
{
providerRepository = (ProviderRepository)base.Factory.RepositoryFactory.CreateRepository(typeof(ProviderRepository));
userRepository = (UserRepository)base.Factory.RepositoryFactory.CreateRepository(typeof(UserRepository));
specialtyRepository = (SpecialtyRepository)base.Factory.RepositoryFactory.CreateRepository(typeof(SpecialtyRepository));
countryRepository = (CountryRepository)base.Factory.RepositoryFactory.CreateRepository(typeof(CountryRepository));
cityRepository = (CityRepository)base.Factory.RepositoryFactory.CreateRepository(typeof(CityRepository));
localityRepository = (LocalityRepository)base.Factory.RepositoryFactory.CreateRepository(typeof(LocalityRepository));
practiceRepository = (PracticeRepository)base.Factory.RepositoryFactory.CreateRepository(typeof(PracticeRepository));
providerPracticeRepository = (ProviderPracticeRepository)base.Factory.RepositoryFactory.CreateRepository(typeof(ProviderPracticeRepository));
providerRepository.DataContext = base.Context;
userRepository.DataContext = base.Context;
specialtyRepository.DataContext = base.Context;
countryRepository.DataContext = base.Context;
cityRepository.DataContext = base.Context;
localityRepository.DataContext = base.Context;
practiceRepository.DataContext = base.Context;
providerPracticeRepository.DataContext = base.Context;
}
public void SetUp()
{
var config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var connectionString = config["connectionStrings:realConnection"];
var options = new DbContextOptionsBuilder <LiveHAPIContext>()
.UseSqlServer(connectionString)
.Options;
_context = new LiveHAPIContext(options);
_practiceRepository = new PracticeRepository(_context);
_personRepository = new PersonRepository(_context);
_clientRepository = new ClientRepository(_context);
_clientService = new ClientService(_practiceRepository, new PersonRepository(_context),
new ClientRepository(_context), new InvalidMessageRepository(_context));
_syncManagerService = new SyncManagerService(new ClientStageRepository(_context));
_summaryService = new SummaryService(new ItemRepository(_context), new ClientSummaryRepository(_context), new UserSummaryRepository(_context), new EncounterRepository(_context), _syncManagerService);
}
public void SetUp()
{
var config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var connectionString = config["connectionStrings:hAPIConnection"];
var options = new DbContextOptionsBuilder <LiveHAPIContext>()
.UseSqlServer(connectionString)
.Options;
_context = new LiveHAPIContext(options);
TestData.Init();
TestDataCreator.Init(_context);
_clientInfos = TestData.TestClientInfos();
_practiceRepository = new PracticeRepository(_context);
_personRepository = new PersonRepository(_context);
_clientRepository = new ClientRepository(_context);
_clientService = new ClientService(_practiceRepository, new PersonRepository(_context),
new ClientRepository(_context), new InvalidMessageRepository(_context));
}
public static void PracticeRecordsAreTypeI()
{
var practices = new Dictionary<string, PracticeRecord>();
var repository = new PracticeRepository(SourcePath, "*REXT.CSV");
int nonMatches = 0;
foreach (var practice in repository.List())
{
var key = practice.Code;
if (!practices.ContainsKey(key))
{
practices[key] = practice;
}
else
{
var other = practices[key];
switch (other.Code)
{
case "A82028":
case "B83017":
case "B86047":
case "C81633":
break;
default:
if (!practice.Equals(other))
{
nonMatches++;
}
break;
}
}
}
Assert.Equal(0, nonMatches);
}
public static void RepositoryReturnsAllTheRecords()
{
var repository = new PracticeRepository(SourcePath, "*REXT.CSV");
var recordCount = repository.List().Count();
Assert.True(recordCount > 10000);
}
public void SetUp()
{
var config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
//var connectionString = config["connectionStrings:hAPIConnection"].Replace("#dir#", TestContext.CurrentContext.TestDirectory.HasToEndWith(@"\"));
var connectionString = config["connectionStrings:livehAPIConnection"];
var options = new DbContextOptionsBuilder <LiveHAPIContext>()
.UseSqlServer(connectionString)
.Options;
_reader = new ClientUserReader(new RestClient(_baseUrl));
_context = new LiveHAPIContext(options);
var clientPretestStageRepository = new ClientPretestStageRepository(_context);
var clientEncounterRepository = new ClientEncounterRepository(_context);
var subscriberSystemRepository = new SubscriberSystemRepository(_context);
var practiceRepository = new PracticeRepository(_context);
var clientStageRepository = new ClientStageRepository(_context);
var clientStageExtractor = new ClientStageExtractor(new PersonRepository(_context), clientStageRepository, subscriberSystemRepository, new ClientRepository(_context), new PracticeRepository(_context));
var clientPretestStageExtractor = new ClientPretestStageExtractor(clientStageRepository, clientPretestStageRepository, subscriberSystemRepository, clientEncounterRepository, new ClientRepository(_context));
var contactsEncounterRepository = new ContactsEncounterRepository(_context);
var clientMessageLoader =
new IndexClientMessageLoader(practiceRepository, clientStageRepository, clientPretestStageRepository,
new ClientTestingStageExtractor(clientEncounterRepository, subscriberSystemRepository),
new ClientFinalTestStageExtractor(clientEncounterRepository, subscriberSystemRepository),
new ClientReferralStageExtractor(clientEncounterRepository, subscriberSystemRepository),
new ClientTracingStageExtractor(clientEncounterRepository, subscriberSystemRepository),
new ClientLinkageStageExtractor(clientEncounterRepository, subscriberSystemRepository)
);
var clientMessageWriter =
new IndexClientMessageWriter(new RestClient(_baseUrl), clientMessageLoader, clientStageRepository);
var cclientMessageLoader =
new FamilyClientMessageLoader(
practiceRepository, clientStageRepository, new ClientStageRelationshipRepository(_context),
new ClientFamilyScreeningStageExtractor(contactsEncounterRepository, subscriberSystemRepository),
new ClientFamilyTracingStageExtractor(contactsEncounterRepository, subscriberSystemRepository));
var cclientMessageWriter =
new FamilyClientMessageWriter(new RestClient(_baseUrl), cclientMessageLoader, clientStageRepository);
var ccclientMessageLoader =
new PartnerClientMessageLoader(
practiceRepository, clientStageRepository, new ClientStageRelationshipRepository(_context),
new ClientPartnerScreeningStageExtractor(contactsEncounterRepository, subscriberSystemRepository),
new ClientPartnerTracingStageExtractor(contactsEncounterRepository, subscriberSystemRepository));
var ccclientMessageWriter =
new PartnerClientMessageWriter(new RestClient(_baseUrl), ccclientMessageLoader, clientStageRepository);
_service = new SyncClientsService(clientMessageWriter, ccclientMessageWriter, cclientMessageWriter);
}
void IUnitOfWork.InitializeRepositories()
{
practiceRepository = (PracticeRepository)base.Factory.RepositoryFactory.CreateRepository(typeof(PracticeRepository));
practiceRepository.DataContext = base.Context;
}
private void UploadButton_Click(object sender, EventArgs e)
{
if (empDataTable == null || (empDataTable != null && empDataTable.Rows.Count == 0))
{
MessageBox.Show("No data to upload");
return;
}
try
{
EmployeeRepository repository = new EmployeeRepository();
DropDownSubCategoryRepository subCategoryRepository = new DropDownSubCategoryRepository();
PracticeRepository practiceRepo = new PracticeRepository();
SubPracticeRepository subPracticeRepo = new SubPracticeRepository();
foreach (DataRow row in empDataTable.Rows)
{
try
{
if (repository.IsDuplicateEmployeeID(row["EmpID"].ToString().Trim()))
{
row["UploadStatus"] = "Failed";
row["StatusMessage"] = "Duplicate Employee ID";
continue;
}
if (repository.IsDuplicateName(row["FirstName"].ToString().Trim(), row["LastName"].ToString().Trim()))
{
row["UploadStatus"] = "Failed";
row["StatusMessage"] = "Duplicate Employee Name";
continue;
}
DropDownSubCategoryDto buType = subCategoryRepository.GetByName(row["BU"].ToString(), (int)CategoryType.BusinessUnit);
string empID = row["EmpID"].ToString();
string empType = "Permanent";
if (empID.StartsWith("CE"))
{
empType = "Contractor";
}
else if (empID.StartsWith("CI"))
{
empType = "Internship";
}
else if (empID.StartsWith("YTJ"))
{
empType = "Yet to Join";
}
DropDownSubCategoryDto employmentType = subCategoryRepository.GetByName(empType, (int)CategoryType.EmploymentType);
PracticeDto practiceDto = practiceRepo.GetByNameOrDefault(row["POD"].ToString());
SubPracticeDto subPracticeDto = subPracticeRepo.GetByName(row["Competency"].ToString(), practiceDto.PracticeID);
EmployeeDto entry = new EmployeeDto
{
BusinessUnitID = buType.SubCategoryID,
DateOfJoin = DateTime.Parse(row["DoJ"].ToString()),
EmployeeID = empID,
EmploymentTypeID = employmentType.SubCategoryID,
FirstName = row["FirstName"].ToString(),
LastName = row["LastName"].ToString(),
PracticeID = practiceDto.PracticeID,
PrimarySkills = row["PrimarySkills"].ToString(),
SecondarySkills = row["SecondarySkills"].ToString(),
SubPracticeID = subPracticeDto.SubPracticeID,
};
if (string.IsNullOrWhiteSpace(row["LWD"].ToString()) == false)
{
entry.LastWorkingDay = DateTime.Parse(row["LWD"].ToString());
}
repository.Add(entry);
row["UploadStatus"] = "Successfully Uploaded";
row["StatusMessage"] = "";
}
catch (Exception exp)
{
row["UploadStatus"] = "Failed";
row["StatusMessage"] = exp.Message;
}
}
}
catch (Exception exp)
{
MessageBox.Show(exp.Message);
}
}
public static void ParseScheduleFromExcel(DataRowCollection rows, PracticeRepository practiceRepository, ScheduleRepository scheduleRepository, CompetenceRepository competenceRepository)
{
string practiceName = "";
string practiceSemestr = "";
string educationYear = "";
foreach (DataRow row in rows)
{
PracticeSchedule schedule = new PracticeSchedule();
Practice practice = new Practice();
if (row[0].ToString() == "")
{
//break;
}
if (row[0].ToString().ToLower().Contains("практика"))
{
practiceName = row[0].ToString().Split(".")[0];
practiceSemestr = row[0].ToString().ToLower().Split("семестр")[1].Replace(" ", "");
}
if (row[5].ToString().Contains("год"))
{
educationYear = row[5].ToString().ToLower().Split("уч")[0].Replace(" ", "");
}
if (int.TryParse(row[0].ToString(), out int s))
{
schedule.EducationYear = educationYear;
practice.Semestr = practiceSemestr;
practice.Name = practiceName;
practice.PracticeView = row[6].ToString();
practice.PracticeType = row[7].ToString();
practice.WeeksNumber = int.Parse(row[8].ToString().Replace(" ", ""));
schedule.SchedulePage = "";
schedule.WeeksNumber = practice.WeeksNumber;
schedule.GroupNumber = row[1].ToString();
schedule.HeadFcs = row[2].ToString();
schedule.Vector = row[3].ToString();
string year = row[4].ToString().ToLower().Split("по")[1].Replace(" ", "").Split(".")[2].Split("г")[0];
schedule.StartDate = DateTime.ParseExact(row[4].ToString().ToLower().Split("с")[1].Split("по")[0].Replace(" ", "") + "." + year, "d.M.yyyy", null);
schedule.EndDate = DateTime.ParseExact(row[4].ToString().ToLower().Split("по")[1].Replace(" ", "").Split("г")[0], "d.M.yyyy", null);
#region Hours
schedule.StudentsNumber = studentsViewModel.GetStudentsCountByGroup(schedule.GroupNumber);
schedule.ExamenHours = (float)Math.Round(0.35 * schedule.StudentsNumber, 2);
schedule.HoursClass = 4;
if (practice.PracticeType.ToLower() == "концентрированная")
{
if (schedule.StudentsNumber > 15)
{
schedule.HoursSum = (float)Math.Round(2.5 * 6 * schedule.WeeksNumber, 2);
}
else
{
schedule.HoursSum = (schedule.StudentsNumber * schedule.WeeksNumber);
}
}
else
{
schedule.HoursSum = (2 * schedule.WeeksNumber) + schedule.ExamenHours;
}
schedule.HoursSRS = schedule.HoursSum - schedule.HoursClass - schedule.ExamenHours;
#endregion
practiceRepository.SavePractice(practice);
practiceRepository.Save();
schedule.PracticeId = practiceRepository.Select(practice).Id;
scheduleRepository.SaveSchedule(schedule);
scheduleRepository.Save();
foreach (var item in row[5].ToString().Split("\n"))
{
Competence competence = new Competence();
competence.PracticeScheduleId = scheduleRepository.Select(schedule).Id;
competence.ThisCompetence = item;
if (competence.ThisCompetence != "")
{
competenceRepository.SaveCompetence(competence);
competenceRepository.Save();
}
}
}
}
}
