public async Task Update_ShouldReturnNull_WhenEntityDoesNotExist()
{
using (var connection = new SqliteConnection("DataSource=:memory:"))
{
connection.Open();
// Setup
var options = new DbContextOptionsBuilder <DotNetCoreTrainingContext>()
.UseSqlite(connection)
.Options;
using (var context = new DotNetCoreTrainingContext(options))
{
await context.Database.EnsureCreatedAsync();
}
// Act
Model.Training result;
using (var context = new DotNetCoreTrainingContext(options))
{
var repo = new TrainingRepository(context);
result = await repo.UpdateAsync(3, new Model.Training());
}
// Assert
Assert.Null(result);
}
}
static void Main(string[] args)
{
TrainingRepository trainingRepository = new TrainingRepository();
Console.WriteLine("A list of courses");
Console.WriteLine("******************");
foreach (var item in trainingRepository.ListCourses())
{
Console.WriteLine(item.CourseCode + " " + item.CourseName + " " + item.CreatedBy);
}
Console.WriteLine();
Console.WriteLine("The upcoming courses");
Console.WriteLine("********************");
trainingRepository.GetUpcomingCourse();
Console.WriteLine();
Console.WriteLine("Delegate Info");
Console.WriteLine("********************");
trainingRepository.GetDelegateInfo();
Console.ReadLine();
}
public HttpResponseMessage GetTrainingProgram(int trainingId)
{
var repo = new TrainingRepository();
var dbResults = repo.GetTrainingProgramById(trainingId);
return(Request.CreateListRecordsResponse(dbResults));
}
public void SendEmailsForSport_WithoutMock(int sportId, int?locationId, int?categoryId, int?teamId, bool?selected, bool?volunteerOnly, int expected)
{
IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.test.json").Build();
var connectionString = config["TrainingDatabase"];
var options = new DbContextOptionsBuilder <PwsodbContext>().UseSqlServer(connectionString).Options;
PwsodbContext context = new PwsodbContext(options);
const string plainTextContent = "testing PWSO sending text messages";
CoachTextDto message = new CoachTextDto
{
SportId = sportId,
Message = plainTextContent,
IsVolunteer = volunteerOnly,
Selected = selected,
ProgramId = locationId,
SportTypeId = categoryId,
TeamId = teamId
};
ITrainingRepository trainingRepository = new TrainingRepository(context);
var accountSid = config["AccountSid"];
var authToken = config["AuthToken"];
var fromPhone = config["FromPhone"];
ISmsRepository emailRepository = new SmsRepository(accountSid, authToken, fromPhone);
TextWorker worker = new TextWorker(trainingRepository, emailRepository);
//var actual = worker.SendSmsForSport(message);
//Assert.Equal(expected, actual.Result);
}
public virtual dynamic GetEmployeeAndRelatedTraining(int employeeId)
{
IEnumerable <Training> trainingList = new TrainingRepository().GetAll().Result;
IEnumerable <Employee> employeeList = new EmployeeRepository().GetAll().Result;
IEnumerable <TrainingEmployee> trainingEmployeeList = new TrainingEmployeeRepository().GetAll().Result;
try
{
var result = from emp in employeeList
join combo in trainingEmployeeList on emp.EmployeeId equals combo.EmployeeId
join train in trainingList on combo.TrainingId equals train.TrainingId
select new
{
EmployeeId = emp.EmployeeId,
EmployeeName = emp.EmployeeName,
TrainingName = train.TrainingName
};
return(result.Where(item =>
item.EmployeeId == employeeId));
}
catch (Exception e)
{
Console.WriteLine("Error in combining training and employee : " + e);
return(new List <dynamic>());
}
}
public async Task CanDelete()
{
using var context = new DataContext(ContextOptions);
var user = await GetUser(context);
var trainingRepo = new TrainingRepository(context);
var training = await CreateTraining(context, user);
trainingRepo.Add(training);
var saved = await trainingRepo.SaveAll();
Assert.IsTrue(saved);
var trainingsReturned = await trainingRepo.GetAllByUserId(user.Id);
Assert.AreEqual(1, trainingsReturned.Count());
trainingRepo.Delete(trainingsReturned.ElementAt(0));
await trainingRepo.SaveAll();
var trainingsReturnedAfterDelete = await trainingRepo.GetAllByUserId(user.Id);
Assert.IsEmpty(trainingsReturnedAfterDelete);
var trainingExercisesAfterDelete = await context.TrainingExercises.ToListAsync();
Assert.IsEmpty(trainingExercisesAfterDelete);
var trainingExerciseSetsAfterDelete = await context.TrainingExerciseSets.ToListAsync();
Assert.IsEmpty(trainingExerciseSetsAfterDelete);
}
public HttpResponseMessage GetAllUpcoming()
{
var repo = new TrainingRepository();
var dbResults = repo.GetAllUpcoming();
return(Request.CreateListRecordsResponse(dbResults));
}
public HttpResponseMessage Delete(int trainingId)
{
var repo = new TrainingRepository();
var dbResult = repo.Delete(trainingId);
return(Request.CreateUpdateRecordResponse(dbResult));
}
public HttpResponseMessage Update(TrainingProgram dto)
{
var repo = new TrainingRepository();
var dbResult = repo.Update(dto);
return(Request.CreateUpdateRecordResponse(dbResult));
}
static void Main()
{
ISessionFactory _sessionFactory = NhibernateService.OpenSessionFactory();
IWindowFormsFactory formsFactory = new WindowFormsFactory();
PlayerRepository playerRepository = new PlayerRepository();
TrainerRepository trainerRepository = new TrainerRepository();
AdminRepository adminRepository = new AdminRepository();
TrainingRepository trainingRepository = new TrainingRepository();
TeamRepository teamRepository = new TeamRepository();
TransactionRepository transactionRepository = new TransactionRepository();
MainController mainController = new MainController(
formsFactory,
playerRepository,
trainerRepository,
adminRepository,
trainingRepository,
teamRepository,
transactionRepository,
new AdminController(),
new PlayerController(),
new TrainerController(),
new AuthController());
mainController.LoadDefaultModel();
Application.SetHighDpiMode(HighDpiMode.SystemAware);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new FormLogIn(mainController));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
try
{
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
var registrantDb = JsonSerializer.Deserialize <RegistrantDb>(requestBody);
var organizationConnectionString = System.Environment.GetEnvironmentVariable("SQLCONNSTR_OrganizationModel");
var organizationOptions = new DbContextOptionsBuilder <PwsoContext>().UseSqlServer(organizationConnectionString ?? throw new InvalidOperationException()).Options;
var organizationContext = new PwsoContext(organizationOptions);
IOrganizationRepository organizationRepository = new OrganizationRepository(organizationContext);
var athlete = await organizationRepository.FindAthleteByName(registrantDb.FirstName, registrantDb.LastName);
var worker = new RegistrantMessageWorker(registrantDb);
var registrantSQL = worker.BuildRegistrant();
var trainingConnectionString = System.Environment.GetEnvironmentVariable("SQLAZURECONNSTR_TrainingModel");
var trainingOptions = new DbContextOptionsBuilder <PwsodbContext>().UseSqlServer(trainingConnectionString ?? throw new InvalidOperationException()).Options;
var trainingContext = new PwsodbContext(trainingOptions);
ITrainingRepository trainingRepository = new TrainingRepository(trainingContext);
await trainingRepository.AddRegistrant(registrantSQL);
}
catch (Exception e)
{
log.LogInformation(e.ToString());
return(new BadRequestResult());
}
return(new OkResult());
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic sportEmail = JsonConvert.DeserializeObject <CoachEmailDto>(requestBody);
try
{
var apiKey = System.Environment.GetEnvironmentVariable("ApiKey");
IEmailRepository emailRepository = new EmailRepository(apiKey);
var connectionString = System.Environment.GetEnvironmentVariable("SQLAZURECONNSTR_TrainingModel");
var options = new DbContextOptionsBuilder <PwsodbContext>().UseSqlServer(connectionString).Options;
PwsodbContext context = new PwsodbContext(options);
ITrainingRepository trainingRepository = new TrainingRepository(context);
EmailWorker worker = new EmailWorker(trainingRepository, emailRepository);
var numOfEmails = await worker.SendEmailsForSport(sportEmail);
return((ActionResult) new OkObjectResult(numOfEmails));
}
catch (Exception ex)
{
return((ActionResult) new BadRequestObjectResult(ex));
}
}
public IEnumerable <PoleChartDTO> GetPolesForChartLastMonth(int idAthlete)
{
var poles = GetAllByIdAthlete(idAthlete);
ITrainingRepository trainingRepository = new TrainingRepository(context: _context);
var monthTrainings = trainingSerivice.GetLast30DaysJumpTraining(idAthlete);
var allExercisesAthelete = trainingSerivice.GetAllExerciseForAthele(idAthlete);
var result = new List <PoleChartDTO>();
if (poles != null && monthTrainings != null)
{
foreach (var pole in poles)
{
var counter = allExercisesAthelete.Where(x => x.IdPole == pole.IdPole && monthTrainings.Contains(x.IdTraining)).Count();
if (counter != 0)
{
result.Add(new PoleChartDTO()
{
Name = pole.NameByAthlete, Count = counter
});
}
}
}
return(result);
}
public void SendEmailsForSport_WithoutMock(int sportId, int?locationId, int?categoryId, int?teamId, bool?selected, bool?volunteerOnly, int expected)
{
IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.test.json").Build();
var connectionString = config["TrainingDatabase"];
var options = new DbContextOptionsBuilder <PwsodbContext>().UseSqlServer(connectionString).Options;
PwsodbContext context = new PwsodbContext(options);
var fromEmail = config["FromEmail"];
const string subject = "Sending with SendGrid is Fun";
const string plainTextContent = "and easy to do anywhere, even with C#";
const string htmlContent = "<br>Hi {{deacon}}<br><br> Just a reminder you are the Deacon on Duty for {{month}},<br><br> You will responsible to lock up the church on Sundays after worship. If you are not going to be there then it is your responsibility to get another Deacon to close up for you. You are responsible for taking out the trash. Also make sure the offering baskets are out for the next week.<br><br> If you are going to miss more than one Sunday in {{month}} please change with another deacon";
CoachEmailDto message = new CoachEmailDto
{
SportId = sportId,
From = fromEmail,
HtmlContent = htmlContent,
PlainTextContent = plainTextContent,
Subject = subject,
IsVolunteer = volunteerOnly,
Selected = selected,
ProgramId = locationId,
SportTypeId = categoryId,
TeamId = teamId
};
ITrainingRepository trainingRepository = new TrainingRepository(context);
var apiKey = config["ApiKey"];
IEmailRepository emailRepository = new EmailRepository(apiKey);
EmailWorker worker = new EmailWorker(trainingRepository, emailRepository);
//var actual = worker.SendEmailsForSport(message);
//Assert.Equal(expected, actual.Result);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
var requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic sportMessage = JsonConvert.DeserializeObject <CoachTextDto>(requestBody);
try
{
var accountSid = System.Environment.GetEnvironmentVariable("AccountSid");
var authToken = System.Environment.GetEnvironmentVariable("AuthToken");
var fromPhone = System.Environment.GetEnvironmentVariable("FromPhone");
ISmsRepository smsRepository = new SmsRepository(accountSid, authToken, fromPhone);
var connectionString = System.Environment.GetEnvironmentVariable("SQLAZURECONNSTR_TrainingModel");
var options = new DbContextOptionsBuilder <PwsodbContext>().UseSqlServer(connectionString ?? throw new InvalidOperationException()).Options;
var context = new PwsodbContext(options);
ITrainingRepository trainingRepository = new TrainingRepository(context);
var worker = new TextWorker(trainingRepository, smsRepository);
var numOfSms = await worker.SendSmsForSport(sportMessage);
return((ActionResult) new OkObjectResult(numOfSms));
}
catch (Exception ex)
{
return((ActionResult) new BadRequestObjectResult(ex));
}
}
public HrUnitOfWork(IContextFactory <DbContext> contextFactory) // , int companyId, string culture
: base(contextFactory)
{
// Initialize
CompanyRepository = new CompanyRepository(Context); // , companyId, culture
PagesRepository = new PagesRepository(Context);
MenuRepository = new MenuRepository(Context);
PageEditorRepository = new PageEditorRepository(Context);
LookUpRepository = new LookUpRepoitory(Context);
CompanyStructureRepository = new CompanyStructureRepository(Context);
JobRepository = new JobRepository(Context);
PeopleRepository = new PeopleRepository(Context);
PositionRepository = new PositionRepository(Context);
BudgetRepository = new BudgetRepository(Context);
QualificationRepository = new QualificationRepository(Context);
LeaveRepository = new LeaveRepository(Context);
EmployeeRepository = new EmployeeRepository(Context);
CustodyRepository = new CustodyRepository(Context);
TrainingRepository = new TrainingRepository(Context);
BenefitsRepository = new BenefitsRepository(Context);
AudiTrialRepository = new AudiTrialRepository(Context);
TerminationRepository = new TerminationRepository(Context);
DisciplineRepository = new DisciplineRepository(Context);
CheckListRepository = new CheckListRepository(Context);
ComplaintRepository = new ComplaintRepository(Context);
MessageRepository = new MessageRepository(Context);
MedicalRepository = new MedicalRepository(Context);
HrLettersRepository = new HRLettersRepository(Context);
PayrollRepository = new PayrollRepository(Context);
SalaryDesignRepository = new SalaryDesignRepository(Context);
NotificationRepository = new NotificationRepository(Context);
MissionRepository = new MissionRepository(Context);
MeetingRepository = new MeetingRepository(Context);
}
//Master objMaster = new Master();
public CheckAccessAttribute()
{
ITrainingRepository service = new TrainingRepository();
ICommonService commonservice = new CommonService();
_service = service;
_commonservice = commonservice;
}
private UnitOfWork()
{
Database.SetInitializer<AthletesFollowUpContext>(new DropCreateDatabaseIfModelChanges<AthletesFollowUpContext>());
context = new AthletesFollowUpContext();
AthleteRepository = new AthleteRepository(context);
TrainingRepository = new TrainingRepository(context);
CompetitionRepository = new CompetitionRepository(context);
}
public Training CreateTraining(int trainingTypeId, int ratePerHour)
{
ITrainingRepository trainingRepo = new TrainingRepository(db);
var training = new Training {
TrainingTypeId = trainingTypeId, RatePerHour = ratePerHour
};
trainingRepo.Add(training);
return(training);
}
public TrainingService(
IConfiguration configuration,
TrainingRepository trainings,
TeamMemberRepository members,
IYouTubeService youTubeService,
VideoStreamRepository videoStreams)
{
idlenessMinutesForNewTraining = configuration.GetValue <int>("IdlenessMinutesForNewTraining");
this.trainings = trainings;
this.members = members;
this.youTubeService = youTubeService;
this.videoStreams = videoStreams;
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# PWSO receive sms message process.");
var requestBody = await new StreamReader(req.Body).ReadToEndAsync();
log.LogInformation(requestBody);
var formValues = requestBody.Split('&')
.Select(value => value.Split('='))
.ToDictionary(pair => Uri.UnescapeDataString(pair[0]).Replace("+", " "),
pair => Uri.UnescapeDataString(pair[1]).Replace("+", " "));
var dto = new EventTextDto
{
Message = formValues["Body"],
From = formValues["From"],
Zip = formValues["FromZip"],
City = formValues["FromCity"]
};
//var dto = new EventTextDto{Message = "Track", From = "17035901821", Zip = "22193", City = "Dale City"} ;
string responseMessage;
try
{
var connectionString = System.Environment.GetEnvironmentVariable("SQLAZURECONNSTR_TrainingModel");
var azureConnectionString = System.Environment.GetEnvironmentVariable("AzureStorageConnectionString");
var options = new DbContextOptionsBuilder <PwsodbContext>().UseSqlServer(connectionString ?? throw new InvalidOperationException()).Options;
var context = new PwsodbContext(options);
ITrainingRepository trainingRepository = new TrainingRepository(context);
IRefRepository refRepository = new RefRepository(azureConnectionString);
var worker = new RegistrantWorker(trainingRepository, refRepository);
var notification = worker.AddNumberForEvent(dto);
responseMessage = notification.Result.Message;
}
catch (Exception e)
{
log.LogError("Fatal Error: " + e.ToString());
throw;
}
responseMessage += ". This message is from the PWSO Notification System.";
return(new OkObjectResult(responseMessage));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic teams = JsonConvert.DeserializeObject <TournamentDto>(requestBody);
try
{
var apiKey = System.Environment.GetEnvironmentVariable("ApiKey");
IEmailRepository emailRepository = new EmailRepository(apiKey);
var connectionString = System.Environment.GetEnvironmentVariable("SQLAZURECONNSTR_TrainingModel");
var options = new DbContextOptionsBuilder <PwsodbContext>().UseSqlServer(connectionString).Options;
PwsodbContext context = new PwsodbContext(options);
ITrainingRepository trainingRepository = new TrainingRepository(context);
IReferenceRepository referenceRepository = new ReferenceRepository(context);
ReferenceWorker refWorker = new ReferenceWorker(referenceRepository);
EmailWorker emailWorker = new EmailWorker(trainingRepository, emailRepository);
var accountSid = System.Environment.GetEnvironmentVariable("AccountSid");
var authToken = System.Environment.GetEnvironmentVariable("AuthToken");
var fromPhone = System.Environment.GetEnvironmentVariable("FromPhone");
ISmsRepository smsRepository = new SmsRepository(accountSid, authToken, fromPhone);
var textWorker = new TextWorker(trainingRepository, smsRepository);
foreach (var team in teams.Teams)
{
var emailMessage = refWorker.ChampionshipEmailPreparation(team);
var textMessage = refWorker.ChampionshipTextPreparation(team);
var numOfEmails = await emailWorker.SendEmailsForSport(emailMessage);
var numOfSms = await textWorker.SendSmsForSport(textMessage);
}
return((ActionResult) new OkObjectResult(1));
}
catch (Exception ex)
{
return((ActionResult) new BadRequestObjectResult(ex));
}
}
public void GetRegistrantsForSport_WithoutMock(int sportId, int expected)
{
IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.test.json").Build();
var trainingConnectionString = config["TrainingDatabase"];
var organizationConnectionString = config["OrganizationDatabase"];
var trainingOptions = new DbContextOptionsBuilder <PwsodbContext>().UseSqlServer(trainingConnectionString).Options;
var organizationOptions = new DbContextOptionsBuilder <PwsoContext>().UseSqlServer(organizationConnectionString).Options;
PwsodbContext trainingContext = new PwsodbContext(trainingOptions);
PwsoContext organizationContext = new PwsoContext(organizationOptions);
ITrainingRepository trainingRepository = new TrainingRepository(trainingContext);
IOrganizationRepository organizationRepository = new OrganizationRepository(organizationContext);
RegistrantWorker worker = new RegistrantWorker(trainingRepository, organizationRepository);
//var actual = worker.GetRegistrantsForSport(sportId);
//Assert.Equal(expected, actual.Result.Count);
}
public async Task CanAdd()
{
using var context = new DataContext(ContextOptions);
var user = await GetUser(context);
var trainingRepo = new TrainingRepository(context);
trainingRepo.Add(await CreateTraining(context, user));
await trainingRepo.SaveAll();
var trainingsReturned = await trainingRepo.GetAllByUserId(user.Id);
var training0 = trainingsReturned.ElementAt(0);
Assert.AreEqual(1, trainingsReturned.Count());
Assert.AreEqual(1, training0.Id);
Assert.AreEqual(1, training0.Exercises.Count());
Assert.AreEqual("Training 1", training0.Name);
Assert.AreEqual("User", training0.User.Username);
var training0Exercise0 = training0.Exercises.ElementAt(0);
Assert.AreEqual(1, training0Exercise0.Id);
Assert.AreEqual("Exercise 1", training0Exercise0.Exercise.Name);
Assert.NotNull(training0Exercise0.Sets);
var trainig0Exercise0Set0 = training0Exercise0.Sets.ElementAt(0);
Assert.AreEqual(1, trainig0Exercise0Set0.Id);
Assert.AreEqual(10, trainig0Exercise0Set0.Reps);
Assert.AreEqual(80, trainig0Exercise0Set0.Weight);
Assert.AreEqual("kg", trainig0Exercise0Set0.Unit.Code
);
var trainig0Exercise0Set1 = training0Exercise0.Sets.ElementAt(1);
Assert.AreEqual(2, trainig0Exercise0Set1.Id);
Assert.AreEqual(10, trainig0Exercise0Set1.Reps);
Assert.AreEqual(85, trainig0Exercise0Set1.Weight);
Assert.AreEqual("kg", trainig0Exercise0Set1.Unit.Code
);
}
public void UpdateDistance()
{
Console.WriteLine("Enter Training id:");
string trainingId = Console.ReadLine();
int tryint;
while (!int.TryParse(trainingId, out tryint))
{
Console.WriteLine("Incorrect id! Try again ");
trainingId = Console.ReadLine();
}
Console.Write("Enter new distance:");
string newDistance = Console.ReadLine();
while ((!int.TryParse(newDistance, out tryint)) || (!DistanceValidationAttribute.IsValidDistance(Convert.ToInt32(newDistance))))
{
Console.WriteLine("Incorrect distance! Try again ");
newDistance = Console.ReadLine();
}
try
{
Training training = new Training {
Distance = Convert.ToInt32(newDistance)
};
using (swimmingContext swimdb = new swimmingContext())
{
ITrainingManager <Training> trainingManager = new TrainingRepository(swimdb);
trainingManager.Update(Convert.ToInt32(trainingId), training);
Console.WriteLine("Distance is updated");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task Update_ShouldUpdate_And_ReturnUpdatedEntity()
{
using (var connection = new SqliteConnection("DataSource=:memory:"))
{
connection.Open();
// Setup
var options = new DbContextOptionsBuilder <DotNetCoreTrainingContext>()
.UseSqlite(connection)
.Options;
using (var context = new DotNetCoreTrainingContext(options))
{
await context.Database.EnsureCreatedAsync();
}
var model = new Model.Training
{
TrainerId = 1,
Name = "Test training 111",
StartDate = DateTime.Today,
EndDate = DateTime.Today
};
// Act
Model.Training result;
using (var context = new DotNetCoreTrainingContext(options))
{
var repo = new TrainingRepository(context);
result = await repo.UpdateAsync(2, model);
}
// Assert
Assert.NotNull(result);
Assert.Equal(model.Name, result.Name);
Assert.Equal(model.StartDate, result.StartDate);
Assert.Equal(model.EndDate, result.EndDate);
}
}
public void CanReadTraining()
{
// Arange
var dbFactory = new DatabaseFactory();
var trainingRepository = new TrainingRepository(dbFactory);
var unitOfWork = new UnitOfWork(dbFactory);
trainingRepository.Add(new TRAINING
{
TRAINING_INTERNAL_ID = "1",
DURATION = 3,
NOTES = "something",
TRAININGTHEME = "something",
TRAININGTYPE = "something",
STARTDATE = System.DateTime.Now,
COACH = new COACH {
COACH_INTERNAL_ID = "1",
PAYMENTRATE = 120.2M,
PAYOFFRATE = 100.2M,
PERSON = new PERSON
{
FIRSTNAME = "Milan",
LASTNAME = "Milanovic",
EMAIL = "*****@*****.**",
TELEPHONE = "0644325665"
}
}
});
unitOfWork.Commit();
// Act
var training = trainingRepository.Get(t => t.TRAINING_INTERNAL_ID == "1");
// Assert
Assert.IsNotNull(training, "training doesn't exist");
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
string sport = req.Query["sportid"];
var requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
sport = sport ?? data?.name;
var sportId = int.Parse(sport);
try
{
var trainingConnectionString = System.Environment.GetEnvironmentVariable("SQLAZURECONNSTR_TrainingModel");
var organizationConnectionString = System.Environment.GetEnvironmentVariable("SQLCONNSTR_OrganizationModel");
var trainingOptions = new DbContextOptionsBuilder <PwsodbContext>().UseSqlServer(trainingConnectionString ?? throw new InvalidOperationException()).Options;
var organizationOptions = new DbContextOptionsBuilder <PwsoContext>().UseSqlServer(organizationConnectionString ?? throw new InvalidOperationException()).Options;
var trainingContext = new PwsodbContext(trainingOptions);
var organizationContext = new PwsoContext(organizationOptions);
ITrainingRepository trainingRepository = new TrainingRepository(trainingContext);
IOrganizationRepository organizationRepository = new OrganizationRepository(organizationContext);
var worker = new RegistrantWorker(trainingRepository, organizationRepository);
var registrantList = await worker.GetRegistrantsForSport(sportId);
return((ActionResult) new OkObjectResult(registrantList));
}
catch (Exception ex)
{
return((ActionResult) new BadRequestObjectResult(ex));
}
}
public TrainingService(TrainingRepository trainingRepository, IEntityService entityService)
{
_trainingRepository = trainingRepository;
_entityService = entityService;
}
public TrainingVisitsService(string connectionString)
{
this.tainingVisitRepository = new TrainingVisitRepository(connectionString);
this.tainingRepository = new TrainingRepository(connectionString);
this.employeeRepository = new EmployeeRepository(connectionString);
}
public void AddTraining()
{
int tryint;
Console.Write("Enter Swimmer Id:");
string swimmertrainingId = Console.ReadLine();
while (!int.TryParse(swimmertrainingId, out tryint))
{
Console.WriteLine("Incorrect Id! Try again ");
swimmertrainingId = Console.ReadLine();
}
Console.Write("Enter Swim Style Id:");
string swimStyleId = Console.ReadLine();
while (!int.TryParse(swimStyleId, out tryint))
{
Console.WriteLine("Incorrect Id! Try again ");
swimStyleId = Console.ReadLine();
}
string trainingDate = Console.ReadLine();
DateTime temp;
while (!DateTime.TryParse(trainingDate, out temp))
{
Console.WriteLine("Incorrect Date! Try again ");
trainingDate = Console.ReadLine();
}
string distance = Console.ReadLine();
while (!int.TryParse(distance, out tryint))
{
Console.WriteLine("Incorrect Distance! Try again ");
distance = Console.ReadLine();
}
try
{
Training training = new Training
{
SwimmerId = Convert.ToInt32(swimmertrainingId),
SwimStyleId = Convert.ToInt32(swimStyleId),
TrainingDate = Convert.ToDateTime(trainingDate),
Distance = Convert.ToInt32(distance)
};
using (swimmingContext swimdb = new swimmingContext())
{
ITrainingManager <Training> trainingManager = new TrainingRepository(swimdb);
trainingManager.Add(training);
Console.WriteLine("Training is added");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public LoginController(TrainingRepository repository)
{
_repository = repository;
}
