public static void UserEditing(UserDto userDto)
        {
            User user = AutoMapperConfiguration.mapper.Map <User>(userDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                try
                {
                    placementDepartmentDB.Configuration.ValidateOnSaveEnabled = false;
                    placementDepartmentDB.User.Attach(user);
                    placementDepartmentDB.Entry(user).Property(x => x.name).IsModified         = true;
                    placementDepartmentDB.Entry(user).Property(x => x.email).IsModified        = true;
                    placementDepartmentDB.Entry(user).Property(x => x.permissionId).IsModified = true;
                    placementDepartmentDB.Entry(user).Property(x => x.isActive).IsModified     = true;

                    placementDepartmentDB.SaveChanges();
                }
                catch (DbUpdateException ex)
                {
                    var sqlException = ex.GetBaseException() as SqlException;
                    if (sqlException != null)
                    {
                        if (sqlException.Number == 2627)
                        {
                            throw new Exception("Duplicate");
                        }
                    }
                }
            }
        }
        public static FullGraduateDto NewGraduate(FullGraduateDto graduateDto)
        {
            Graduate graduate = AutoMapperConfiguration.mapper.Map <Graduate>(graduateDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                try
                {
                    graduate.dateOfRegistration = graduate.lastUpdate = DateTime.Now;
                    var res = placementDepartmentDB.Graduate.Add(graduate);
                    placementDepartmentDB.SaveChanges();
                    return(AutoMapperConfiguration.mapper.Map <FullGraduateDto>(res));
                }
                catch (DbUpdateException ex)
                {
                    var sqlException = ex.GetBaseException() as SqlException;
                    if (sqlException != null)
                    {
                        if (sqlException.Number == 2627)
                        {
                            throw new Exception("Duplicate");
                        }
                    }
                    return(null);
                }
            }
        }
        public static void NewUser(UserDto userDto)
        {
            User user = AutoMapperConfiguration.mapper.Map <User>(userDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                try
                {
                    placementDepartmentDB.Configuration.ValidateOnSaveEnabled = false;
                    placementDepartmentDB.User.Add(user);
                    placementDepartmentDB.SaveChanges();
                }
                catch (DbUpdateException ex)
                {
                    var sqlException = ex.GetBaseException() as SqlException;
                    if (sqlException != null)
                    {
                        if (sqlException.Number == 2627)
                        {
                            throw new Exception("Duplicate");
                        }
                    }
                }
            }
        }
Exemple #4
0
 public static void placedGraduateJob(List <int> idCRDs)
 {
     using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
     {
         foreach (var idCRD in idCRDs)
         {
             CoordinatingJobsForGraduates coordinating = placementDepartmentDB.CoordinatingJobsForGraduates.Find(idCRD);
             coordinating.placementStatus       = 6;
             coordinating.JobCoordinationStatus = null;
             coordinating.lastUpdateDate        = DateTime.Now;
             //Job
             coordinating.Job.isActive                    = false;
             coordinating.Job.reasonForClosing            = 5; //work
             coordinating.Job.ReasonForClosingThePosition = null;
             coordinating.Job.lastUpdateDate              = DateTime.Now;
             //Graduate
             coordinating.Graduate.isWorkerInProfession           = true;
             coordinating.Graduate.placedByThePlacementDepartment = true;
             coordinating.Graduate.lastUpdate  = DateTime.Now;
             coordinating.Graduate.companyName = coordinating.Job.Contact.Company.name;
             coordinating.Graduate.role        = coordinating.Job.Subject.name;
             placementDepartmentDB.SaveChanges();
         }
     }
 }
Exemple #5
0
 public static void JobsCoordinationUpdate(List <int> idCoordinatingJobsForGraduate, int statusId)
 {
     if (statusId == 6)//work
     {
         placedGraduateJob(idCoordinatingJobsForGraduate);
     }
     else
     {
         List <CoordinatingJobsForGraduates> coordinations = new List <CoordinatingJobsForGraduates>();
         foreach (var item in idCoordinatingJobsForGraduate)
         {
             coordinations.Add(new CoordinatingJobsForGraduates()
             {
                 Id = item,
                 placementStatus = statusId,
                 lastUpdateDate  = DateTime.Now
             });
         }
         using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
         {
             foreach (var coordination in coordinations)
             {
                 placementDepartmentDB.Configuration.ValidateOnSaveEnabled = false;
                 placementDepartmentDB.CoordinatingJobsForGraduates.Attach(coordination);
                 placementDepartmentDB.Entry(coordination).Property(x => x.placementStatus).IsModified = true;
                 placementDepartmentDB.Entry(coordination).Property(x => x.lastUpdateDate).IsModified  = true;
             }
             placementDepartmentDB.SaveChanges();
         }
     }
 }
Exemple #6
0
        public static void NewCompany(CompanyDto companyDto)
        {
            Company company = AutoMapperConfiguration.mapper.Map <Company>(companyDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Company.Add(company);
                placementDepartmentDB.SaveChanges();
            }
        }
 public static void DeleteEwithS(int idExpertise, int idSubject)
 {
     using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
     {
         Expertise expertise = placementDepartmentDB.Expertise.Find(idExpertise);
         Subject   subject   = expertise.Subject.Single(s => s.Id == idSubject);
         expertise.Subject.Remove(subject);
         placementDepartmentDB.SaveChanges();
     }
 }
Exemple #8
0
        public static void CompanyEditing(CompanyDto companyDto)
        {
            Company company = AutoMapperConfiguration.mapper.Map <Company>(companyDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Company.Attach(company);
                placementDepartmentDB.Entry(company).State = EntityState.Modified;
                placementDepartmentDB.SaveChanges();
            }
        }
Exemple #9
0
        public static List <CoordinatingJobsForGraduates> NewJobsCoordination(List <CoordinatingJobsForGraduates> JobsCoordination)
        {
            List <CoordinatingJobsForGraduates> res;

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                res = placementDepartmentDB.CoordinatingJobsForGraduates.AddRange(JobsCoordination).ToList();
                placementDepartmentDB.SaveChanges();
                return(res);
            }
        }
        public static int NewExpertise(ExpertiseDto expertiseDto)
        {
            Expertise expertise = AutoMapperConfiguration.mapper.Map <Expertise>(expertiseDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                expertise = placementDepartmentDB.Expertise.Add(expertise);
                placementDepartmentDB.SaveChanges();
                return(expertise.Id);
            }
        }
Exemple #11
0
        public static void editLanguage(LanguageDto LanguageDto)
        {
            Language Language = AutoMapperConfiguration.mapper.Map <Language>(LanguageDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Language.Attach(Language);
                placementDepartmentDB.Entry(Language).State = EntityState.Modified;
                placementDepartmentDB.SaveChanges();
            }
        }
Exemple #12
0
        public static int NewLanguage(LanguageDto LanguageDto)
        {
            Language Language = AutoMapperConfiguration.mapper.Map <Language>(LanguageDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                Language = placementDepartmentDB.Language.Add(Language);
                placementDepartmentDB.SaveChanges();
                return(Language.Id);
            }
        }
        public static void editCity(CityDto CityDto)
        {
            City City = AutoMapperConfiguration.mapper.Map <City>(CityDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.City.Attach(City);
                placementDepartmentDB.Entry(City).State = EntityState.Modified;
                placementDepartmentDB.SaveChanges();
            }
        }
        public static void editExpertise(ExpertiseDto expertiseDto)
        {
            Expertise expertise = AutoMapperConfiguration.mapper.Map <Expertise>(expertiseDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Expertise.Attach(expertise);
                placementDepartmentDB.Entry(expertise).State = EntityState.Modified;
                placementDepartmentDB.SaveChanges();
            }
        }
Exemple #15
0
        public static void NewContact(ContactDto contactDto)
        {
            Contact contact = AutoMapperConfiguration.mapper.Map <Contact>(contactDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Configuration.ValidateOnSaveEnabled = false;
                placementDepartmentDB.Contact.Add(contact);
                placementDepartmentDB.SaveChanges();
            }
        }
        public static int NewCity(CityDto CityDto)
        {
            City City = AutoMapperConfiguration.mapper.Map <City>(CityDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                City = placementDepartmentDB.City.Add(City);
                placementDepartmentDB.SaveChanges();
                return(City.Id);
            }
        }
        public static int NewBranch(BranchDto branchDto)
        {
            Branch branch = AutoMapperConfiguration.mapper.Map <Branch>(branchDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                branch = placementDepartmentDB.Branch.Add(branch);
                placementDepartmentDB.SaveChanges();
                return(branch.Id);
            }
        }
        public static void editBranch(BranchDto branchDto)
        {
            Branch branch = AutoMapperConfiguration.mapper.Map <Branch>(branchDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Branch.Attach(branch);
                placementDepartmentDB.Entry(branch).State = EntityState.Modified;
                placementDepartmentDB.SaveChanges();
            }
        }
Exemple #19
0
        public static int NewSubject(SubjectDto SubjectDto)
        {
            Subject Subject = AutoMapperConfiguration.mapper.Map <Subject>(SubjectDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                Subject = placementDepartmentDB.Subject.Add(Subject);
                placementDepartmentDB.SaveChanges();
                return(Subject.Id);
            }
        }
Exemple #20
0
        public static void editSubject(SubjectDto SubjectDto)
        {
            Subject Subject = AutoMapperConfiguration.mapper.Map <Subject>(SubjectDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Subject.Attach(Subject);
                placementDepartmentDB.Entry(Subject).State = EntityState.Modified;
                placementDepartmentDB.SaveChanges();
            }
        }
        public static void JobEditing(JobDto JobDto)
        {
            Job Job = AutoMapperConfiguration.mapper.Map <Job>(JobDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                Job.lastUpdateDate = DateTime.Now;
                placementDepartmentDB.Job.Attach(Job);
                placementDepartmentDB.Entry(Job).State = EntityState.Modified;
                placementDepartmentDB.SaveChanges();
            }
        }
Exemple #22
0
 public static void DeleteJobsCoordination(List <int> ids)
 {
     using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
     {
         foreach (var id in ids)
         {
             CoordinatingJobsForGraduates JobsCoordination = placementDepartmentDB.CoordinatingJobsForGraduates.Find(id);
             placementDepartmentDB.CoordinatingJobsForGraduates.Remove(JobsCoordination);
         }
         placementDepartmentDB.SaveChanges();
     }
 }
        public static void GraduateEditing(FullGraduateDto graduateDto)
        {
            ReGraduateLanguages(graduateDto.Id, graduateDto.Languages);
            Graduate graduate = AutoMapperConfiguration.mapper.Map <Graduate>(graduateDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                graduate.lastUpdate = DateTime.Now;
                placementDepartmentDB.Graduate.Attach(graduate);
                placementDepartmentDB.Entry(graduate).State = EntityState.Modified;
                placementDepartmentDB.SaveChanges();
            }
        }
        public static void ReGraduateLanguages(string graduateId, List <GraduateLanguagesDto> languages)
        {
            List <GraduateLanguages> graduateLanguages = AutoMapperConfiguration.mapper.Map <List <GraduateLanguages> >(languages);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.GraduateLanguages.RemoveRange(
                    placementDepartmentDB.GraduateLanguages.Where(gl =>
                                                                  gl.graduateId == graduateId
                                                                  ).ToList()
                    );
                placementDepartmentDB.GraduateLanguages.AddRange(graduateLanguages);
                placementDepartmentDB.SaveChanges();
            }
        }
        public static int NewJob(JobDto JobDto)
        {
            int newJobId;
            Job Job = AutoMapperConfiguration.mapper.Map <Job>(JobDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Configuration.ValidateOnSaveEnabled = false;
                Job.dateReceived = Job.lastUpdateDate = DateTime.Now;
                Job = placementDepartmentDB.Job.Add(Job);
                placementDepartmentDB.SaveChanges();
                newJobId = Job.Id;
            }
            return(newJobId);
        }
        public static void JobUpdate(int idJob, bool didSendCV)
        {
            Job job = new Job()
            {
                Id = idJob, didSendCV = didSendCV, lastUpdateDate = DateTime.Now
            };

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Configuration.ValidateOnSaveEnabled = false;
                placementDepartmentDB.Job.Attach(job);
                placementDepartmentDB.Entry(job).Property(x => x.didSendCV).IsModified      = true;
                placementDepartmentDB.Entry(job).Property(x => x.lastUpdateDate).IsModified = true;
                placementDepartmentDB.SaveChanges();
            }
        }
        public static void GraduateUploudFile(string graduateId, string filePath)
        {
            Graduate graduate = new Graduate()
            {
                Id = graduateId, linkToCV = filePath, lastUpdate = DateTime.Now
            };

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Configuration.ValidateOnSaveEnabled = false;
                placementDepartmentDB.Graduate.Attach(graduate);
                placementDepartmentDB.Entry(graduate).Property(x => x.linkToCV).IsModified   = true;
                placementDepartmentDB.Entry(graduate).Property(x => x.lastUpdate).IsModified = true;
                placementDepartmentDB.SaveChanges();
            }
        }
        public static void GraduateEditingtrue(string id, bool isint)
        {
            Graduate graduate = new Graduate()
            {
                Id = id, isActive = isint, lastUpdate = DateTime.Now
            };

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Configuration.ValidateOnSaveEnabled = false;
                placementDepartmentDB.Graduate.Attach(graduate);
                placementDepartmentDB.Entry(graduate).Property(x => x.isActive).IsModified   = true;
                placementDepartmentDB.Entry(graduate).Property(x => x.lastUpdate).IsModified = true;
                placementDepartmentDB.SaveChanges();
            }
        }
 public static void NewEwithS(int idExpertise, SubjectDto subjectDto)
 {
     using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
     {
         Expertise expertise = placementDepartmentDB.Expertise.Find(idExpertise);
         Subject   subject   = placementDepartmentDB.Subject.Find(subjectDto.Id);
         if (!expertise.Subject.Contains(subject))
         {
             expertise.Subject.Add(subject);
             placementDepartmentDB.SaveChanges();
         }
         else
         {
             throw new Exception("Duplicate");
         }
     }
 }
        public static void ChangePassword(int id, bool isInit, string hashPassword)
        {
            User user = new User()
            {
                Id = id,
                isInitialPassword = isInit,
                password          = hashPassword
            };

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Configuration.ValidateOnSaveEnabled = false;
                placementDepartmentDB.User.Attach(user);
                placementDepartmentDB.Entry(user).Property(x => x.isInitialPassword).IsModified = true;
                placementDepartmentDB.Entry(user).Property(x => x.password).IsModified          = true;
                placementDepartmentDB.SaveChanges();
            }
        }