/// <summary>
/// Deserialize JSON into a FHIR EnrollmentRequest
/// </summary>
public static void DeserializeJson(this EnrollmentRequest current, ref Utf8JsonReader reader, JsonSerializerOptions options)
{
string propertyName;
while (reader.Read())
{
if (reader.TokenType == JsonTokenType.EndObject)
{
return;
}
if (reader.TokenType == JsonTokenType.PropertyName)
{
propertyName = reader.GetString();
if (Hl7.Fhir.Serialization.FhirSerializerOptions.Debug)
{
Console.WriteLine($"EnrollmentRequest >>> EnrollmentRequest.{propertyName}, depth: {reader.CurrentDepth}, pos: {reader.BytesConsumed}");
}
reader.Read();
current.DeserializeJsonProperty(ref reader, options, propertyName);
}
}
throw new JsonException($"EnrollmentRequest: invalid state! depth: {reader.CurrentDepth}, pos: {reader.BytesConsumed}");
}
public async Task <dynamic> Add(EnrollmentRequest model)
{
if (model.UserId == 0 || model.CourseId == 0)
{
return(null);
}
var user = await(from u in this.context.Users
where u.Id == model.UserId
select u).FirstOrDefaultAsync();
var course = await(from u in this.context.Courses
where u.Id == model.CourseId
select u).FirstOrDefaultAsync();;
if (user == null || course == null)
{
return(null);
}
Enrollment enrollment = new Enrollment {
User = user, Course = course
};
return(enrollment);
//this.context.Enrollments.Add(enrollment);
//return await this.context.SaveChangesAsync();
}
public IActionResult EnrollNewStudent(EnrollmentRequest enrollmentRequest)
{
List <Error> errorsList = ValidationHelper.ValidateEnrollmentRequest(enrollmentRequest);
if (!errorsList.Count.Equals(0))
{
return(StatusCode(400, errorsList));
}
var studentExists = _studentDbService.StudentExists(enrollmentRequest.IndexNumber);
if (studentExists)
{
return(BadRequest("Student with index " + enrollmentRequest.IndexNumber + " already exists"));
}
var studyExists = _enrollmentDbService.StudyExists(enrollmentRequest.Studies);
if (!studyExists)
{
return(NotFound("Studies " + enrollmentRequest.Studies + " does not exist"));
}
var enrollmentExists = _enrollmentDbService.EnrollmentExists(1, enrollmentRequest.Studies);
if (!enrollmentExists)
{
return(NotFound("Enrollment for semester 1 for " + enrollmentRequest.Studies + " does not exist"));
}
var response = _enrollmentDbService.EnrollStudent(enrollmentRequest);
return(StatusCode(201, response));
}
public async Task <IActionResult> EnrollStudent(EnrollmentRequest enrollmentRequest)
{
if (enrollmentRequest is null)
{
return(BadRequest());
}
var studies = _context.Studies.Where(i => i.Name == enrollmentRequest.Studies).First();
var enrollment = _context.Enrollment.Where(i => i.IdStudy == studies.IdStudy && i.Semester == 1).DefaultIfEmpty().First();
if (enrollment is null)
{
enrollment = new Enrollment();
enrollment.IdStudy = studies.IdStudy;
enrollment.Semester = 1;
enrollment.StartDate = DateTime.Now;
enrollment.IdEnrollment = _context.Enrollment.Max(i => i.IdEnrollment) + 1;
_context.Enrollment.Add(enrollment);
}
var student = new Student(enrollmentRequest.FirstName, enrollmentRequest.LastName);
student.BirthDate = Convert.ToDateTime(enrollmentRequest.BirthDate);
student.idEnrollment = enrollment.IdEnrollment;
student.IndexNumber = enrollmentRequest.IndexNumber;
_context.Student.Add(student);
await _context.SaveChangesAsync();
return(Ok(enrollment));
}
public IActionResult EnrollStudent(EnrollmentRequest enrollment)
{
// sprawdzam poprawność danych
if (enrollment.IndexNumber == "")
{
return(BadRequest());
}
if (enrollment.FirstName == "")
{
return(BadRequest());
}
if (enrollment.LastName == "")
{
return(BadRequest());
}
if (enrollment.BirthDate == "")
{
return(BadRequest());
}
if (enrollment.Studies == "")
{
return(BadRequest());
}
EnrollmentResponse enrollmentResponse = __service.enrollment(enrollment);
if (enrollmentResponse == null)
{
return(BadRequest());
}
return(CreatedAtAction("enroll", enrollmentResponse));
}
/// <inheritdoc/>
public void RequestEnrollment(Person person, string courseId)
{
var course = GetById(courseId);
var newEnrollmentRequest = new EnrollmentRequest(course, person);
dbContext.EnrollmentRequests.Add(newEnrollmentRequest);
}
/// <summary>
/// Send post request to enroll User Record.
/// </summary>
/// <returns>A new instance of the <see cref="EnrollmentResponse"/> class.</returns>
/// <param name="request">An instance of the <see cref="EnrollmentRequest"/> class.</param>
public async Task <EnrollmentResponse> GetEnrollment(EnrollmentRequest request)
{
var response = await this.SendAsync <EnrollmentRequest, EnrollmentResponse>(
HttpMethod.Post, $"phe/v1/enroll", request).ConfigureAwait(false);
return(response);
}
private void erstatuschange_notification(EnrollmentRequest er)
{
if (er.Person == person)
{
listBoxNotifications.Items.Add($"Workshop: {er.Wks.Title}, Enrollment request: {er.Status}");
FillMyWks(er.Person);
}
}
public void SetERStatus(EnrollmentRequest er, string status)
{
er.Status = status;
if (EnrollmentRequestStatusChangeEvent != null)
{
EnrollmentRequestStatusChangeEvent(er);
}
}
public IActionResult enrollStudent(EnrollmentRequest req)
{
Student student = new Student
{
IndexNumber = req.IndexNumber,
LastName = req.LastName,
FirstName = req.FirstName,
BirthDate = req.BirthDate
};
if (!context.Studies.Any(s => s.Name.Equals(req.StudyName)))
{
return(null);
}
if (context.Student.Any(s => s.IndexNumber.Equals(student.IndexNumber)))
{
return(null);
}
Student addStudent = new Student
{
IndexNumber = student.IndexNumber,
LastName = student.LastName,
BirthDate = student.BirthDate,
FirstName = student.FirstName,
IdEnrollment = 1
};
context.Student.Add(addStudent);
context.SaveChanges();
int idStudy = context.Studies.Single(s => s.Name.Equals(req.StudyName)).IdStudy;
int idEnrollment = context.Enrollment.Where(e => e.Semester == 1 && e.IdStudy == idStudy)
.OrderByDescending(e => e.StartDate).First().IdEnrollment;
if (idEnrollment == 0)
{
idEnrollment = context.Enrollment.Max(e => e.IdEnrollment) + 1;
Enrollment newEnrollment = new Enrollment
{
IdEnrollment = idEnrollment,
Semester = 1,
IdStudy = idStudy,
StartDate = DateTime.Now
};
context.Enrollment.Add(newEnrollment);
context.SaveChanges();
}
addStudent.IdEnrollment = idEnrollment;
context.SaveChanges();
var resp = context.Enrollment.Single(e => e.IdEnrollment == idEnrollment);
return(new OkObjectResult(new EnrollmentResult
{
Semester = resp.Semester,
IdStudy = resp.IdStudy,
StartDate = resp.StartDate,
IdEnrollment = resp.IdEnrollment
}));
}
public async Task <string> Post([FromBody] EnrollmentRequest request)
{
var message = new CreateEnrollment()
{
BclCode = request.BclCode
};
await messageSession.Send(message).ConfigureAwait(false);
return("Create Enrollment Command");
}
private void AddStudent(SqlCommand command, EnrollmentRequest request, Enrollment enrollment)
{
command.CommandText = "insert into Student (IndexNumber, FirstName, LastName, BirthDate, IdEnrollment) VALUES (@indexNumber, @firstName, @lastName, @birthDate, @idEnrollment); ";
command.Parameters.AddWithValue("indexNumber", request.IndexNumber);
command.Parameters.AddWithValue("firstName", request.FirstName);
command.Parameters.AddWithValue("lastName", request.LastName);
command.Parameters.AddWithValue("birthDate", request.BirthDate);
command.Parameters.AddWithValue("idEnrollment", enrollment.IdEnrollment);
command.ExecuteNonQuery();
}
public IActionResult EnrollStudent(EnrollmentRequest request)
{
var result = _idbService.EnrollStudent(request);
if (result == null)
{
return(BadRequest("An error occurred!"));
}
return(Ok(result));
}
public void TestEnrollmentNoServerResponse()
{
ICryptoSuite cryptoSuite = Factory.Instance.GetCryptoSuite();
EnrollmentRequest req = new EnrollmentRequest("profile 1", "label 1", null);
HFCAClient client = HFCAClient.Create("client", "http://localhost:99", null);
client.CryptoSuite = cryptoSuite;
client.Enroll(TEST_ADMIN_NAME, TEST_ADMIN_NAME, req);
}
public EnrollmentRequest Get(int id)
{
EnrollmentRequest result = null;
var enrollment = _context.Enrollments.FirstOrDefault(x => x.Id == id);
if (enrollment != null)
{
result = _toDomainMapper.Map(enrollment);
}
return(result);
}
public void Add(EnrollmentRequest request)
{
var documents = request.Person.Documents.Select(x => x.Type + x.Number);
if (_context.Enrollments.Any(x => documents.Contains(x.TypeIdentification + x.Identification)))
{
throw new EnrollmentAlreadyExistsException();
}
_context.Add(_toInfrastructureMapper.Map(request));
_context.SaveChanges();
}
private void btnDenyER_Click(object sender, EventArgs e)
{
if (listBoxEnrollementRequests.SelectedIndex == -1)
{
MessageBox.Show("Please select a request.");
return;
}
EnrollmentRequest er = (EnrollmentRequest)listBoxEnrollementRequests.SelectedItem;
enrollmentreq.SetERStatus(er, "Denied");
listBoxEnrollementRequests.Items.Remove(er);
}
public IActionResult EnrollStudent(EnrollmentRequest request)
{
try
{
var result = _dbService.EnrollStudent(request);
return(Ok(result));
}
catch (Exception e)
{
return(BadRequest());
}
}
public IActionResult EnrollStudent(EnrollmentRequest request)
{
EnrollmentRequest helpme = _service.EnrollStudent(request);
if (helpme == null)
{
return(BadRequest());
}
else
{
return(Ok(helpme));
}
}
public string Post(EnrollmentRequest request)
{
svc.CompleteEnrollment(request.CompanyId);
var enrollmentDoneEvent = new EnrollmentDone()
{
CompanyId = request.CompanyId
};
ServiceBusEndpoint.Publish(enrollmentDoneEvent).GetAwaiter().GetResult();
return("Created Enrollment Command");
}
public IActionResult EnrollStudent(EnrollmentRequest student)
{
var enrollment = _dbService.EnrollStudent(student);
if (enrollment is null)
{
return(BadRequest());
}
else
{
return(Ok(enrollment));
}
}
public OperationStatus Post([FromBody] RegisterViewModel registerViewModel)
{
var enrollmentRequest = new EnrollmentRequest
{
LastName = registerViewModel.LastName,
AccountNumber = registerViewModel.AccountNumber,
Username = registerViewModel.Username,
Password = registerViewModel.Password
};
var oppStatus = service.Enroll(enrollmentRequest);
return(oppStatus);
}
public void EnrollIdemixUser(SampleStore sampleStore)
{
foreach (SampleOrg sampleOrg in testSampleOrgs)
{
HFCAClient ca = sampleOrg.CAClient;
string orgName = sampleOrg.Name;
string mspid = sampleOrg.MSPID;
ca.CryptoSuite = Factory.GetCryptoSuite();
if (testConfig.IsRunningFabricTLS())
{
//This shows how to get a client TLS certificate from Fabric CA
// we will use one client TLS certificate for orderer peers etc.
EnrollmentRequest enrollmentRequestTLS = new EnrollmentRequest();
enrollmentRequestTLS.AddHost("localhost");
enrollmentRequestTLS.Profile = "tls";
IEnrollment enroll = ca.Enroll("admin", "adminpw", enrollmentRequestTLS);
string tlsCertPEM = enroll.Cert;
string tlsKeyPEM = enroll.Key;
Properties tlsProperties = new Properties();
tlsProperties["clientKeyBytes"] = tlsKeyPEM;
tlsProperties["clientCertBytes"] = tlsCertPEM;
clientTLSProperties[sampleOrg.Name] = tlsProperties;
//Save in samplestore for follow on tests.
sampleStore.StoreClientPEMTLCertificate(sampleOrg, tlsCertPEM);
sampleStore.StoreClientPEMTLSKey(sampleOrg, tlsKeyPEM);
}
HFCAInfo info = ca.Info(); //just check if we connect at all.
Assert.IsNotNull(info);
string infoName = info.CAName;
if (infoName != null && infoName.Length > 0)
{
Assert.AreEqual(ca.CAName, infoName);
}
SampleUser admin = sampleStore.GetMember(TEST_ADMIN_NAME, orgName);
SampleUser idemixUser = sampleStore.GetMember(testUser1, sampleOrg.Name);
EnrollIdemixUser(sampleOrg, idemixUser, admin);
sampleOrg.AddUser(idemixUser);
}
}
public IActionResult PromoteStudents(EnrollmentRequest enrollment)
{
using (var con = new SqlConnection(ConnectionString))
using (var comm = new SqlCommand("", con))
{
con.Open();
comm.CommandText = "SELECT TOP 1 * FROM Enrollment, Studies WHERE Enrollment.Semester = @semester AND Studies.Name = @studyName AND Enrollment.IdStudy = Studies.IdStudy";
comm.Parameters.AddWithValue("semester", enrollment.Semester);
comm.Parameters.AddWithValue("studyName", enrollment.Studies);
var reader = comm.ExecuteReader();
if (!reader.Read())
{
return(StatusCode(404));
}
reader.Close();
}
var newEnrollment = new Enrollment();
using (var con = new SqlConnection(ConnectionString))
using (var comm = new SqlCommand("", con))
{
con.Open();
comm.CommandType = System.Data.CommandType.StoredProcedure;
comm.CommandText = "UpdateStudent";
comm.Parameters.Add(new SqlParameter("@Semester", enrollment.Semester));
comm.Parameters.Add(new SqlParameter("@Studies", enrollment.Studies));
var reader = comm.ExecuteReader();
reader.Read();
newEnrollment = new Enrollment
{
IdEnrollment = (int)reader["IdEnrollment"],
IdStudy = (int)reader["IdStudy"],
Semester = (int)reader["Semester"],
StartDate = (DateTime)reader["StartDate"]
};
reader.Close();
}
return(StatusCode(201, newEnrollment));
}
public void AddER(EnrollmentRequest er)
{
foreach (EnrollmentRequest e in ers)
{
if (e.Wks.ID == er.Wks.ID && e.Person.PCN == er.Person.PCN)
{
throw new Exception("You already requested to enroll to this workshop.");
}
}
ers.Add(er);
if (EnrollmentRequestEvent != null)
{
EnrollmentRequestEvent(er);
}
}
public IActionResult CreateEnrollment([FromBody] EnrollmentRequest request)
{
var study = _context.Studies
.Where(s => s.Name == request.Studies)
.FirstOrDefault();
if (study == null)
{
return(BadRequest("study not found"));
}
var enrollent = _context.Enrollment
.Where(e => e.IdStudy == study.IdStudy)
.Where(e => e.Semester == 1)
.FirstOrDefault();
if (enrollent == null)
{
enrollent = new Enrollment();
Random rnd = new Random();
// should be set by db sequence
enrollent.IdEnrollment = rnd.Next(1, 10000);
enrollent.IdStudy = study.IdStudy;
enrollent.Semester = 1;
enrollent.StartDate = DateTime.Today;
_context.Enrollment.Add(enrollent);
}
var student = new Student();
student.IndexNumber = request.IndexNumber;
student.FirstName = request.FirstName;
student.LastName = request.LastName;
student.BirthDate = request.BirthDate;
student.IdEnrollment = enrollent.IdEnrollment;
_context.Student.Add(student);
_context.SaveChanges();
var response = new EnrollmentResponse();
response.LastName = student.LastName;
response.Semester = enrollent.Semester;
response.StartDate = enrollent.StartDate;
return(Ok(response));
}
public void TestEnrollReqToJsonAttrNotThere()
{
EnrollmentRequest testEnrollReq = new EnrollmentRequest();
testEnrollReq.AddHost("d.com");
testEnrollReq.CSR = csr;
testEnrollReq.Profile = profile;
testEnrollReq.Label = label;
testEnrollReq.KeyPair = null;
testEnrollReq.CAName = caName;
string s = testEnrollReq.ToJson();
Assert.IsNotNull(s);
Assert.IsFalse(s.Contains("\"attr_reqs\":["));
}
public void TestNewInstanceEmpty()
{
try
{
EnrollmentRequest testEnrollReq = new EnrollmentRequest();
Assert.IsNull(testEnrollReq.CSR);
Assert.IsTrue(testEnrollReq.Hosts.Count == 0);
Assert.IsNull(testEnrollReq.Profile);
Assert.IsNull(testEnrollReq.Label);
Assert.IsNull(testEnrollReq.KeyPair);
}
catch (System.Exception e)
{
Assert.Fail($"Unexpected Exception {e.Message}");
}
}
public void TestNewInstanceParms()
{
try
{
EnrollmentRequest testEnrollReq = new EnrollmentRequest(profile, label, keyPair);
Assert.IsNull(testEnrollReq.CSR);
Assert.IsTrue(testEnrollReq.Hosts.Count == 0);
Assert.AreEqual(testEnrollReq.Profile, profile);
Assert.AreEqual(testEnrollReq.Label, label);
Assert.IsNull(testEnrollReq.KeyPair);
}
catch (System.Exception e)
{
Assert.Fail("Unexpected Exception " + e.Message);
}
}
public void TestEnrollReqToJsonAttrEmpty()
{
EnrollmentRequest testEnrollReq = new EnrollmentRequest();
testEnrollReq.AddHost("d.com");
testEnrollReq.CSR = csr;
testEnrollReq.Profile = profile;
testEnrollReq.Label = label;
testEnrollReq.KeyPair = null;
testEnrollReq.CAName = caName;
testEnrollReq.AddAttrReq(); // means empty. force no attributes.
string s = testEnrollReq.ToJson();
Assert.IsNotNull(s);
Assert.IsTrue(s.Contains("\"attr_reqs\":[]") || !s.Contains("\"attr_reqs\""));
}
