public static void AddSingleToManyRelationships(DataBaseContext context, DbSpecialization specialization, List <DbAvailability> availabilities)
 {
     foreach (var availability in availabilities)
     {
         AddSingleRelationship(context, specialization, availability);
     }
 }
Esempio n. 2
0
        public void Should_CRUD_correctly()
        {
            var user           = new User("email", "Ivan", UserType.Candidate);
            var specialization = new Specialization("Specialization");
            var skills         = new List <Skill> {
                new Skill("Skill1"), new Skill("Skill2"), new Skill("Skill3")
            };


            var options = new DbContextOptionsBuilder()
                          .UseInMemoryDatabase("JinderTest")
                          .Options;

            using var context = new JinderContext(options);

            var dbUser           = DbUser.FromModel(user);
            var dbSpecialization = DbSpecialization.FromModel(specialization);
            var dbSkills         = skills.Select(DbSkill.FromModel).ToList();

            context.Users.Add(dbUser);
            context.Specializations.Add(dbSpecialization);
            context.Skills.AddRange(dbSkills);
            context.SaveChanges();

            user           = context.Users.SingleOrDefault()?.ToModel();
            specialization = context.Specializations.SingleOrDefault()?.ToModel();
            skills         = context.Skills.Select(s => s.ToModel()).ToList();

            Assert.IsNotNull(user);
            Assert.IsNotNull(specialization);
            Assert.IsNotNull(skills.Aggregate((a, b) => (a is null) || (b is null) ? null : a));

            var summary   = new Summary(user, specialization, skills, "Information");
            var dbSummary = DbSummary.FromModel(summary);

            context.Summaries.Add(dbSummary);
            context.SaveChanges();

            summary = context.Summaries.SingleOrDefault()?.ToModel();
            Assert.IsNotNull(summary);

            context.Summaries.Remove(dbSummary);
            context.SaveChanges();

            user           = context.Users.SingleOrDefault()?.ToModel();
            specialization = context.Specializations.SingleOrDefault()?.ToModel();
            skills         = context.Skills.Select(s => s.ToModel()).ToList();
            summary        = context.Summaries.SingleOrDefault()?.ToModel();

            Assert.IsNotNull(user);
            Assert.IsNotNull(specialization);
            Assert.IsNotNull(skills.Aggregate((a, b) => (a is null) || (b is null) ? null : a));
            Assert.IsNull(summary);

            summary   = new Summary(user, specialization, skills, "Information");
            dbSummary = DbSummary.FromModel(summary);

            Assert.DoesNotThrow(() => context.Summaries.Add(dbSummary));
        }
Esempio n. 3
0
        public Specialization Add(Specialization specialization)
        {
            DbSpecialization dbSpecialization = DbSpecialization.FromModel(specialization);

            dbSpecialization = _context.Specializations
                               .Add(dbSpecialization)
                               .Entity;

            try
            {
                _context.SaveChanges();
            }
            catch (DbUpdateException)
            {
                throw new ArgumentException("Unable to create skill with such data!");
            }

            return(dbSpecialization.ToModel());
        }
Esempio n. 4
0
        public Specialization DeleteByName(String specializationName)
        {
            DbSpecialization dbSpecialization = _context.Specializations
                                                .SingleOrDefault(s => s.Name == specializationName) ??
                                                throw new ArgumentException($"No skill with name {specializationName}!");

            dbSpecialization = _context.Specializations
                               .Remove(dbSpecialization)
                               .Entity;

            try
            {
                _context.SaveChanges();
            }
            catch (DbUpdateException)
            {
                throw new ArgumentException("Unable to delete specialization with such name!");
            }

            return(dbSpecialization.ToModel());
        }
 public static void AddSingleRelationship(DataBaseContext context, DbMedicalWorker medicalWorker, DbSpecialization specialization)
 {
     context.MedicalWorkers.SingleOrDefault(mw => mw.Id == medicalWorker.Id).Specializations.Add(context.Specializations.SingleOrDefault(s => s.Id == specialization.Id));
     context.Specializations.SingleOrDefault(s => s.Id == specialization.Id).MedicalWorkers.Add(context.MedicalWorkers.SingleOrDefault(mw => mw.Id == medicalWorker.Id));
 }
Esempio n. 6
0
 private static void AddSingleRelationship(DataBaseContext context, DbVisit visit, DbSpecialization specialization)
 {
     context.Visits.SingleOrDefault(v => v.Id == visit.Id).Specialization = context.Specializations.SingleOrDefault(s => s.Id == specialization.Id);
 }
Esempio n. 7
0
 public static void AddSingleCompleteRelationships(DataBaseContext context, DbVisit visit, DbMedicalWorker medicalWorker, DbPatient patient, DbSpecialization specialization)
 {
     if (!medicalWorker.Specializations.Contains(context.Specializations.SingleOrDefault(x => x.Id == specialization.Id)))
     {
         throw new Exception("In function AddSingleCompleteRelationships medicalWorker doesn't have required specialization");
     }
     AddSingleRelationship(context, visit, medicalWorker);
     AddSingleRelationship(context, visit, patient);
     AddSingleRelationship(context, visit, specialization);
 }
 public static void AddSingleRelationship(DataBaseContext context, DbSpecialization specialization, DbAvailability availability)
 {
     context.Specializations.SingleOrDefault(s => s.Id == specialization.Id).Availabilities.Add(context.Availabilities.SingleOrDefault(a => a.Id == availability.Id));
     context.Availabilities.SingleOrDefault(a => a.Id == availability.Id).Specialization = context.Specializations.SingleOrDefault(s => s.Id == specialization.Id);
 }