public IActionResult Enroll(long id, [FromBody] EnrollRequest request)
{
var student = _studentRepository.GetById(id);
if (student == null)
{
return(Error(Errors.General.NotFound(id), nameof(id)));
}
for (var index = 0; index < request.Enrollments.Length; index++)
{
var enrollmentDto = request.Enrollments[index];
var grade = Grade.Create(enrollmentDto.Grade).Value;
var courseName = (enrollmentDto.Course ?? string.Empty).Trim();
var course = _courseRepository.GetByName(courseName);
if (course == null)
{
return(Error(Errors.General.ValueIsInvalid(),
$"{nameof(request.Enrollments)}[{index}].{nameof(enrollmentDto.Course)}"));
}
var result = student.Enroll(course, grade);
if (result.IsFailure)
{
return(Error(result.Error));
}
}
return(Ok());
}
public async void Run_TerminalEnrollTest()
{
ShowTestOnTerminal("TerminalEnroll");
EnrollRequest request = new EnrollRequest
{
TerminalName = IntegrationTestConfiguration.Instance.Settings.DefaultTerminalName,
Test = true,
};
output.WriteLine("Request: {0}", request);
EnrollResponse response = await blockchyp.EnrollAsync(request);
output.WriteLine("Response: {0}", response);
Assert.True(response.Success, "response.Success");
Assert.True(response.Approved, "response.Approved");
Assert.True(response.Test, "response.Test");
Assert.Equal(6, response.AuthCode.Length);
Assert.NotEmpty(response.TransactionId);
Assert.NotEmpty(response.Timestamp);
Assert.NotEmpty(response.TickBlock);
Assert.Equal("approved", response.ResponseDescription);
Assert.NotEmpty(response.PaymentType);
Assert.NotEmpty(response.MaskedPan);
Assert.NotEmpty(response.EntryMethod);
Assert.NotEmpty(response.Token);
}
public async void Run_TokenMetadataTest()
{
ShowTestOnTerminal("TokenMetadata");
EnrollRequest setupRequest = new EnrollRequest
{
Pan = "4111111111111111",
Test = true,
Customer = new Customer
{
CustomerRef = "TESTCUSTOMER",
FirstName = "Test",
LastName = "Customer",
},
};
output.WriteLine("Setup request: {0}", setupRequest);
EnrollResponse setupResponse = await blockchyp.EnrollAsync(setupRequest);
output.WriteLine("Setup Response: {0}", setupResponse);
TokenMetadataRequest request = new TokenMetadataRequest
{
Token = setupResponse.Token,
};
output.WriteLine("Request: {0}", request);
TokenMetadataResponse response = await blockchyp.TokenMetadataAsync(request);
output.WriteLine("Response: {0}", response);
Assert.True(response.Success, "response.Success");
}
public void EnrollStudent(EnrollRequest student)
{
if (student.IndexNumber == null)
{
throw new Exception();
}
if (student.FirstName == null)
{
throw new Exception();
}
if (student.LastName == null)
{
throw new Exception();
}
if (student.BirthDate == null)
{
throw new Exception();
}
if (student.Studies == null)
{
throw new Exception();
}
var st = _context2.Studies.FirstOrDefault(st => st.Name.Equals(student.Studies));
if (st == null)
{
throw new Exception();
}
var st2 = _context3.Enrolment.FirstOrDefault(stu => stu.IdStudy == st.IdStudy && stu.Semester == 1);
var enrollment = new Enrollment();
if (st2 == null)
{
enrollment.IdEnrollment = _context3.Enrolment.Last().IdEnrollment + 1;
enrollment.Semester = 1;
enrollment.StartDate = DateTime.Now;
enrollment.IdStudy = st.IdStudy;
_context3.Add(enrollment);
_context3.SaveChanges();
}
var st3 = _context.Student.FirstOrDefault(st => st.IndexNumber.Equals(student.IndexNumber));
if (st3 != null)
{
throw new Exception();
}
else
{
var student2 = new Student();
student2.IndexNumber = student.IndexNumber;
student2.FirstName = student.FirstName;
student2.LastName = student.LastName;
student2.BirthDate = student.BirthDate;
student2.IdEnrollment = enrollment.IdEnrollment;
}
}
/// <summary>
/// CreateEnrollment request
/// </summary>
/// <param name="userkey">user id</param>
/// <param name="community">community id</param>
/// <param name="cardnumbers">card number</param>
/// <returns>request</returns>
public static EnrollRequest GetCreateEnrollmentRequest(string userkey, string community,
List <string> cardnumbers)
{
var request = new EnrollRequest();
request.AuthenticationDetails = GetExternalAuthenticationRecord(userkey, community);
request.CardDetails = cardnumbers.Select(cardnumber => new CardInfoRequest {
CardNumber = cardnumber
}).ToArray();
request.CardHolderDetails = new UserInfoRequest
{
ExternalUserId = userkey
};
request.CommunityTermsVersion = VisaConstants.CommunityTermsVersion;
request.UserPreferences = new UserPreferences
{
LanguageId = VisaConstants.LanguageId
};
request.UserStatus = VisaConstants.VisaUserStatusActive;
return(request);
}
public void EnrollStudent(EnrollRequest request)
{
using (SqlConnection con = new SqlConnection("Data Source=db-mssql.pjwstk.edu.pl;Initial Catalog=2019SBD;Integrated Security=True"))
using (SqlCommand com = new SqlCommand())
{
com.Connection = con;
var transac = con.BeginTransaction();
com.CommandText = "select studyName Studies where studyName=@par1";
com.Parameters.AddWithValue("par1", request.Studies);
var dr = com.ExecuteReader();
if (!dr.Read())
{
transac.Rollback();
Console.WriteLine("404 Error");
}
com.CommandText = "insert into students (idStudent,firstName,lastName,indexNumber) values (@par1,@par2,@par3,@par4,@par5,par6)";
com.Parameters.AddWithValue("par1", request.idStudent);
com.Parameters.Add("par2", SqlDbType.VarChar, 50).Value = $"s{new Random().Next(1, 20000)}";
com.Parameters.AddWithValue("par3", request.firstName);
com.Parameters.AddWithValue("par4", request.lastName);
com.Parameters.AddWithValue("par5", request.idEnrollment);
com.Parameters.AddWithValue("par6", request.BirthDate);
con.Open();
int affectedRows = com.ExecuteNonQuery();
transac.Commit();
}
}
public IActionResult enrollStudent(EnrollRequest requestStudent)
{
Enrollment enrollment = null;
using (var connection = new SqlConnection("Data Source=db-mssql;Initial Catalog=s19299;Integrated Security=True"))
using (var command = new SqlCommand())
{
command.Connection = connection;
connection.Open();
var transaction = connection.BeginTransaction();
try
{
// czy studia istnieja?
command.CommandText = "select IdStudy from Studies where Name = @course";
command.Parameters.AddWithValue("course", requestStudent.course);
var reader = command.ExecuteReader();
if (!reader.Read())
{
return(NoContent());
}
int idStudies = (int)reader["IdStudy"];
int idEnrollment = (int)reader["IdEnrollment"];
command.CommandText =
"select IdStudy from Studies join Enrollment on Studies.IdStudy = Enrollment.IdStudy where Semester = 1 and Name = @course";
command.Parameters.AddWithValue("course", requestStudent.course);
enrollment = new Enrollment(idEnrollment, idStudies, requestStudent.course, 1);
//dodaje studenta
command.CommandText =
"insert into Student values (@indexNumber, @firstName, @lastName, @birthDate)";
command.Parameters.AddWithValue("indexNumber", requestStudent.indexNumber);
command.Parameters.AddWithValue("firstName", requestStudent.firstName);
command.Parameters.AddWithValue("lastName", requestStudent.lastName);
command.Parameters.AddWithValue("birthDate", requestStudent.birthDate);
command.CommandText =
"select * from Student join Enrollment on Student.IdEnrollment = Enrollment.IdEnrollment";
command.ExecuteNonQuery();
transaction.Commit();
}
catch (SqlException exc)
{
transaction.Rollback();
}
}
return(Ok(enrollment));
}
public IActionResult AddStudent(EnrollRequest request)
{
try
{
return(Ok(_dbService.EnrollStudent(request)));
}catch (Exception exc)
{
return(BadRequest(exc.Message));
}
}
public async Task <IHttpActionResult> SendEmailEnroll([FromBody] EnrollRequest emailRequest)
{
NotificationMessage message = new NotificationMessage();
message.To = emailRequest.ParentEmail;
message.Message = EmailTemplate.getTemplate(TempalteType.EnrollInfo, Mapper.Map <EnrollInfoModel>(emailRequest));
message.Name = emailRequest.FullName;
message.Title = "Enroll for - " + emailRequest.Program;
await EmailService.SendEmail(message);
return(Ok());
}
public Enrollment EnrollStudent(EnrollRequest request)
{
using (var db = new StudentDbContext())
{
var enrollment = new Enrollment();
//sprawdzenie czy studia istnieją
if (!db.Studies.Any(studies => studies.Name == request.Studies))
{
throw new Exception("Studia nie istnieją");
}
var studies = db.Studies.Where(studies => studies.Name == request.Studies).First();
enrollment.Semester = 1;
enrollment.StartDate = DateTime.Parse(DateTime.Now.ToShortTimeString());
enrollment.IdStudy = studies.IdStudy;
//Sprawdzenie czy istnieje enrollment
if (db.Enrollment.Any(e => e.IdStudy == studies.IdStudy && e.Semester == 1 && e.StartDate == db.Enrollment.Max(en => en.StartDate)))
{
var enroll = db.Enrollment.Where(e => e.IdStudy == studies.IdStudy && e.Semester == 1 && e.StartDate == db.Enrollment.Max(en => en.StartDate)).Single();
db.Student.Add(new Student {
IndexNumber = request.IndexNumber, FirstName = request.FirstName, LastName = request.LastName, Birthdate = request.Birthdate, IdEnrollment = enroll.IdEnrollment
});
enrollment.IdEnrollment = enroll.IdEnrollment;
db.SaveChanges();
}
else
{
//sprawdzam czy istnieje student
if (!db.Student.Any(st => st.IndexNumber == request.IndexNumber))
{
throw new Exception("Student już istnieje");
}
else
{
var enrollments = db.Enrollment.Max(emp => emp.IdEnrollment);
Enrollment nowy = new Enrollment {
IdEnrollment = enrollments + 1, Semester = 1, IdStudy = studies.IdStudy, StartDate = DateTime.Now
};
enrollment.IdEnrollment = nowy.IdEnrollment;
db.Enrollment.Add(nowy);
db.Student.Add(new Student {
IndexNumber = request.IndexNumber, FirstName = request.FirstName, LastName = request.LastName, Birthdate = request.Birthdate, IdEnrollment = nowy.IdEnrollment
});
db.SaveChanges();
}
}
return(enrollment);
}
}
public IActionResult PromoteStudent(EnrollRequest request)
{
var enrollment = _dbService.GetEnrollment(request.Studies, request.Semester);
if (enrollment == null)
{
return(NotFound());
}
else
{
_dbService.Promote(request.Studies, request.Semester);
return(StatusCode(201));
}
}
public void DoEnterVipRoom(string psw)
{
PacketBase msg = new PacketBase()
{
packetType = PacketType.EnrollRequest
};
EnrollRequest request = new EnrollRequest()
{
roomCode = psw, gameId = "G_DQMJ"
};
msg.data = NetSerilizer.Serialize(request);
SocketNetTools.SendMsg(msg);
}
public void Enroll(uint deviceID, User.UserInfo[] users)
{
var request = new EnrollRequest {
DeviceID = deviceID
};
request.Users.AddRange(users);
try {
userClient.Enroll(request);
} catch (RpcException e) {
Console.WriteLine("Cannot enroll users {0}: {1}", deviceID, e);
throw;
}
}
/// <summary>
/// Create Card Enrollment Request
/// </summary>
/// <param name="request">request</param>
/// <returns>response</returns>
public async Task <EnrollResponse> CreateEnrollment(EnrollRequest request)
{
EnrollResponse response;
using (var client = VisaRtmClientManager.Instance.GetVisaRtmClient())
{
Stopwatch sprocTimer = Stopwatch.StartNew();
try
{
// Todo: Should remove this later
// Visa has issues to add the same card to multiple users.
// Requests are logged so we can clean up the users using an external tool
#if !XXXDEBUG
string logstring = string.Format("{0} CreateEnrollmentRequest {1} {2}\n",
DateTime.Now.ToString(CultureInfo.InvariantCulture),
request.CardHolderDetails.ExternalUserId,
request.CardDetails[0].CardNumber.Substring(12));
// just the last four digits
File.AppendAllText(Logfilename, logstring);
#endif
response = await client.EnrollAsync(request).ConfigureAwait(false);
#if !XXXDEBUG
if (response.EnrollmentRecord != null && response.EnrollmentRecord.CardDetails.Length > 0)
{
logstring = string.Format("{0} CreateEnrollmentResponse {1} {2}\n",
DateTime.Now.ToString(CultureInfo.InvariantCulture),
response.EnrollmentRecord.CardHolderDetails.ExternalUserId,
response.EnrollmentRecord.CardDetails[0].CardId);
File.AppendAllText(Logfilename, logstring);
}
#endif
}
finally
{
sprocTimer.Stop();
PerformanceInformation.Add("Visa CreateEnrollment ",
String.Format("{0} ms", sprocTimer.ElapsedMilliseconds));
}
}
return(response);
}
public void DoENROLL(string matchType, List <int> cards = null)
{
Game.MJMgr.Clear();
PacketBase msg = new PacketBase()
{
packetType = PacketType.EnrollRequest
};
EnrollRequest request = new EnrollRequest()
{
gameId = "G_DQMJ", matchId = matchType
};
if (null != cards)
{
request.cards.AddRange(cards);
}
msg.data = NetSerilizer.Serialize(request);
SocketNetTools.SendMsg(msg);
}
public IActionResult EnrollStudent(EnrollRequest request)
{
_service.EnrollStudent(request);
var response = new EnrollResponse();
using (SqlConnection con = new SqlConnection("Data Source=db-mssql.pjwstk.edu.pl;Initial Catalog=2019SBD;Integrated Security=True"))
using (SqlCommand com = new SqlCommand())
{
com.Connection = con;
var transac = con.BeginTransaction();
com.CommandText = "select studyName Studies where studyName=@par1";
com.Parameters.AddWithValue("par1", request.Studies);
var dr = com.ExecuteReader();
if (!dr.Read())
{
transac.Rollback();
Console.WriteLine("Error");
}
return(Ok());
}
}
public async void Run_PanEnrollTest()
{
ShowTestOnTerminal("PanEnroll");
EnrollRequest request = new EnrollRequest
{
Pan = "4111111111111111",
Test = true,
Customer = new Customer
{
CustomerRef = "TESTCUSTOMER",
FirstName = "Test",
LastName = "Customer",
},
};
output.WriteLine("Request: {0}", request);
EnrollResponse response = await blockchyp.EnrollAsync(request);
output.WriteLine("Response: {0}", response);
Assert.True(response.Success, "response.Success");
Assert.True(response.Approved, "response.Approved");
Assert.True(response.Test, "response.Test");
Assert.Equal(6, response.AuthCode.Length);
Assert.NotEmpty(response.TransactionId);
Assert.NotEmpty(response.Timestamp);
Assert.NotEmpty(response.TickBlock);
Assert.Equal("approved", response.ResponseDescription);
Assert.NotEmpty(response.PaymentType);
Assert.NotEmpty(response.MaskedPan);
Assert.NotEmpty(response.EntryMethod);
Assert.Equal("KEYED", response.EntryMethod);
Assert.NotEmpty(response.Token);
}
public async void Run_UnlinkTokenTest()
{
ShowTestOnTerminal("UnlinkToken");
EnrollRequest setupRequest = new EnrollRequest
{
Pan = "4111111111111111",
Test = true,
Customer = new Customer
{
CustomerRef = "TESTCUSTOMER",
FirstName = "Test",
LastName = "Customer",
},
};
output.WriteLine("Setup request: {0}", setupRequest);
EnrollResponse setupResponse = await blockchyp.EnrollAsync(setupRequest);
output.WriteLine("Setup Response: {0}", setupResponse);
UnlinkTokenRequest request = new UnlinkTokenRequest
{
Token = setupResponse.Token,
CustomerId = setupResponse.Customer.Id,
};
output.WriteLine("Request: {0}", request);
Acknowledgement response = await blockchyp.UnlinkTokenAsync(request);
output.WriteLine("Response: {0}", response);
Assert.True(response.Success, "response.Success");
}
public EnrollResponse enrollStudent(EnrollRequest requestStudent)
{
using (var connection =
new SqlConnection("Data Source=db-mssql;Initial Catalog=s19299;Integrated Security=True"))
using (var command = new SqlCommand())
{
DateTime startDate = DateTime.Today;
command.Connection = connection;
command.CommandText = "select * from Studies where Name = @name";
command.Parameters.AddWithValue("name", requestStudent.course);
connection.Open();
var reader = command.ExecuteReader();
if (!reader.Read())
{
throw new Exception("nie znaleziono studi: " + requestStudent.course);
}
int idStudies = (int)reader["IdStudy"];
int idEnrollment = 0;
if (this.getStudent(requestStudent.indexNumber) != null)
{
throw new Exception("mamy studenta o podanym indeksie");
}
reader.Close();
command.CommandText =
"select IdStudy from Studies join Enrollment on Studies.IdStudy = Enrollment.IdStudy where Semester = 1 and IdStudy = @IdStudy";
command.Parameters.AddWithValue("IdStudy", idStudies);
reader = command.ExecuteReader();
if (!reader.Read())
{
reader.Close();
command.CommandText = "select count(IdEnrollment) as maxEnroll from ENrollment";
reader = command.ExecuteReader();
if (reader.Read())
{
idEnrollment = (int)reader["maxEnroll"];
}
else
{
idEnrollment = 1;
}
reader.Close();
command.CommandText = "insert into Enrollment values(@idEnrollment, 1, @idStudy, @startDate)";
command.Parameters.AddWithValue("idEnrollment", idEnrollment);
command.Parameters.AddWithValue("idStudy", idStudies);
command.Parameters.AddWithValue("startDate", DateTime.Today);
}
else
{
startDate = (DateTime)reader["startDate"];
idEnrollment = (int)reader["IdEnrollment"];
reader.Close();
}
//dodaje studenta
command.CommandText =
"insert into Student values (@indexNumber, @firstName, @lastName, @birthDate, IdEnrollment)";
command.Parameters.AddWithValue("indexNumber", requestStudent.indexNumber);
command.Parameters.AddWithValue("firstName", requestStudent.firstName);
command.Parameters.AddWithValue("lastName", requestStudent.lastName);
command.Parameters.AddWithValue("birthDate", requestStudent.birthDate);
command.Parameters.AddWithValue("IdEnrollment", idEnrollment);
command.ExecuteNonQuery();
return(new EnrollResponse()
{
idEnrollment = idEnrollment, semester = 1, idStudy = idStudies, start = startDate
});
}
}
public async Task <EnrollResponse> EnrollChild(FPCaptureRs vm)
{
EnrollResponse returnModel = new EnrollResponse();
EnrollRequest request = new EnrollRequest();
request.Id = Guid.NewGuid();
request.FingerprintRecord = new DsdAfis.Core.FingerBiometrics.FingerprintRecord();
request.FingerprintRecord.Id = 0;
request.FingerprintRecord.Active = false;
request.FingerprintRecord.DateTime = DateTime.Now;
request.FingerprintRecord.FingerprintSet = new DsdAfis.Core.FingerBiometrics.FingerprintSet();
request.FingerprintRecord.FingerprintSet.Dpi = 500;
request.FingerprintRecord.FingerprintSet.ImageEncoding = "WSQ";
request.FingerprintRecord.FingerprintSet.ImageHeight = 512;
request.FingerprintRecord.FingerprintSet.ImageWidth = 512;
List <Fingerprint> fingers = new List <Fingerprint>();
Fingerprint blankFinger = null;
fingers.Add(blankFinger);
foreach (Finger f in vm.Fingers)
{
if (f.Sequence > 0)
{
Fingerprint finger = new Fingerprint();
switch (f.Name)
{
case "1":
finger.Code = FingerCode.RightThumb;
break;
case "6":
finger.Code = FingerCode.LeftThumb;
break;
}
finger.EncodedImage = f.Print;
fingers.Add(finger);
}
else
{
fingers.Add(null);
}
}
request.FingerprintRecord.FingerprintSet.Fingerprints = fingers.ToArray();
request.FingerprintRecord.Person = new DsdAfis.Core.Person();
request.FingerprintRecord.Person.Gender = DsdAfis.Core.PersonGender.Unknown;
using (var client = new HttpClient())
{
//Passing service base url
client.BaseAddress = new Uri(ConfigurationManager.AppSettings["WebApiUrl"]);
client.DefaultRequestHeaders.Clear();
//Define request data format
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = await client.PostAsync(
"api/afis/enroll", new StringContent(request.Json, Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
return(MessageBase.Deserialize <EnrollResponse>(response.Content.ReadAsStringAsync().Result));
}
else
{
return(returnModel);
}
}
}
public IActionResult EnrollStudent(EnrollRequest student)
{
_service.EnrollStudent(student);
return(Ok());
}
public EnrollResponse EnrollStudent(EnrollRequest request)
{
EnrollResponse enrollResponse = new EnrollResponse();
using (var client = new SqlConnection("Data Source = db-mssql.pjwstk.edu.pl; Initial Catalog = s16796; Integrated Security = True"))
{
using (var command = new SqlCommand())
{
command.Connection = client;
client.Open();
var transaction = client.BeginTransaction();
command.Transaction = transaction;
command.CommandText = "Select IdStudy FROM Studies where Name=@name";
command.Parameters.AddWithValue("name", request.Studies);
var dr = command.ExecuteReader();
if (!dr.Read())
{
dr.Close();
transaction.Rollback();
throw new ArgumentException("No studies found with that name");
}
else
{
enrollResponse.IdStudies = Convert.ToInt32(dr["IdStudy"].ToString());
enrollResponse.Semester = 1;
enrollResponse.Studies = request.Studies;
}
dr.Close();
command.Parameters.Clear();
command.CommandText = "SELECT IdEnrollment, StartDate FROM Enrollment WHERE semester = 1 AND IdStudy = @id order by StartDate desc";
command.Parameters.AddWithValue("id", enrollResponse.IdStudies);
dr = command.ExecuteReader();
if (dr.Read())
{
enrollResponse.IdEnrollment = Convert.ToInt32(dr["IdEnrollment"].ToString());
enrollResponse.StartDate = Convert.ToDateTime(dr["StartDate"]);
}
else
{
//enrollment nie istnieje!
dr.Close();
command.CommandText = "INSERT INTO Enrollment(IdEnrollment, Semester, IdStudy, StartDate) OUTPUT Inserted.IdEnrollment VALUES((SELECT MAX(IdEnrollment) FROM Enrollment) + 1, 1, @id, @startdate)";
command.Parameters.AddWithValue("startdate", DateTime.Now);
dr = command.ExecuteReader();
dr.Read();
enrollResponse.IdEnrollment = Convert.ToInt32(dr["IdEnrollment"].ToString());
enrollResponse.StartDate = DateTime.Now.Date;
}
dr.Close();
command.Parameters.Clear();
command.CommandText = "INSERT INTO Student(IndexNumber, FirstName, LastName, BirthDate, IdEnrollment) VALUES(@index, @first, @last, @birth, @enrollment)";
command.Parameters.AddWithValue("index", request.IndexNumber);
command.Parameters.AddWithValue("first", request.FirstName);
command.Parameters.AddWithValue("last", request.LastName);
command.Parameters.AddWithValue("birth", DateTime.ParseExact(request.BirthDate, "dd.MM.yyyy", null));
command.Parameters.AddWithValue("enrollment", enrollResponse.IdEnrollment);
try
{
dr = command.ExecuteReader();
enrollResponse.IndexNumber = request.IndexNumber;
}
catch (Exception exc)
{
Console.WriteLine(exc);
dr.Close();
transaction.Rollback();
throw new ArgumentException("This index already exists");
}
dr.Close();
transaction.Commit();
return(enrollResponse);
}
}
}
public EnrollResponse EnrollStudent(EnrollRequest request, s16796Context context)
{
EnrollResponse enrollResponse = new EnrollResponse();
context.Database.BeginTransaction();
var test = context.Student.Where(student => student.IndexNumber.Equals(request.IndexNumber)).FirstOrDefault();
if (test != null)
{
throw new ArgumentException("Index taken!");
}
enrollResponse.IndexNumber = request.IndexNumber;
try
{
enrollResponse.IdStudies = context.Studies.Where(studies => studies.Name.Equals(request.Studies)).Select(studies => studies.IdStudy).FirstOrDefault();
}catch (InvalidOperationException ex)
{
context.Database.RollbackTransaction();
throw new ArgumentException("No studies found with that name");
}
enrollResponse.Semester = 1;
enrollResponse.Studies = request.Studies;
try
{
var output = context.Enrollment.Where(enroll => enroll.Semester == 1 && enroll.IdStudy == enrollResponse.IdStudies).Select(enr => new
{
IdEnrollment = enr.IdEnrollment,
StartDate = enr.StartDate
}).First();
enrollResponse.IdEnrollment = output.IdEnrollment;
enrollResponse.StartDate = output.StartDate;
}catch (InvalidOperationException ex)
{
enrollResponse.IdEnrollment = context.Enrollment.Max(enr => enr.IdEnrollment) + 1;
enrollResponse.StartDate = DateTime.Now.Date;
var enrollmentadd = new Enrollment()
{
IdEnrollment = enrollResponse.IdEnrollment,
Semester = 1,
IdStudy = enrollResponse.IdStudies,
StartDate = enrollResponse.StartDate
};
context.Enrollment.Add(enrollmentadd);
}
var studentsalt = GetSalt(32);
var nowystudent = new Student()
{
IndexNumber = request.IndexNumber,
FirstName = request.FirstName,
LastName = request.LastName,
BirthDate = DateTime.ParseExact(request.BirthDate, "dd.MM.yyyy", null),
IdEnrollment = enrollResponse.IdEnrollment,
Password = PasswordHasherService.GenerateSaltedHash(request.Password, studentsalt),
Salt = studentsalt
};
context.Student.Add(nowystudent);
context.SaveChanges();
context.Database.CommitTransaction();
return(enrollResponse);
}
