コード例 #1
0
        public void addCompany(string companyS, string[] countries)
        {
            var company = new Company
            {
                companyName = companyS,
            };


            for (int i = 0; i < countries.Length; i++)
            {
                var country = new Country {
                    countryName = countries[i]
                };

                CompanyCountry cc = new CompanyCountry {
                    companyId = company.companyId, company = company, countryId = country.countryId, country = country
                };
                companyCountries.Add(cc);
            }
        }
コード例 #2
0
        public async Task <IHttpActionResult> UpdateMyCompanyProfile(CompanyProfileDTO companyProfileDTO)
        {
            string userName          = User.Identity.Name;
            User   authenticatedUser = db.Users.Where(_user => _user.UserName == userName).SingleOrDefault();

            if (authenticatedUser == null)
            {
                throw new HttpResponseException(HttpStatusCode.Unauthorized);
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            User user = db.Users.Find(companyProfileDTO.OwnerID);

            if (user == null)
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }

            if (authenticatedUser != user)
            {
                throw new HttpResponseException(HttpStatusCode.Unauthorized);
            }

            if (companyProfileDTO.URI != null)
            {
                Regex regex = new Regex("[^a-zA-Z0-9_-]");

                companyProfileDTO.URI = companyProfileDTO.URI.Replace(" ", "-");
                companyProfileDTO.URI = regex.Replace(companyProfileDTO.URI, "").ToLower();

                if (companyProfileDTO.URI.Length == 0)
                {
                    companyProfileDTO.URI = null;
                }
                else if (db.Companies.Where(company => company.URI == companyProfileDTO.URI && company.ID != companyProfileDTO.ID).SingleOrDefault() != null)
                {
                    throw new HttpResponseException(HttpStatusCode.BadRequest);
                }
            }
            else if (companyProfileDTO.ID == 0 && companyProfileDTO.URI == null)
            {
                Regex regex = new Regex("[^a-zA-Z0-9_-]");
                companyProfileDTO.URI = companyProfileDTO.DisplayName.Replace(" ", "-");
                companyProfileDTO.URI = regex.Replace(companyProfileDTO.URI, "").ToLower();
            }


            user.Company         = Mapper.Map(companyProfileDTO, user.Company);
            db.Entry(user).State = EntityState.Modified;
            await db.SaveChangesAsync();

            if (companyProfileDTO.Countries != null)
            {
                if (db.CompanyCountries.Any(cc => cc.CompanyId == user.Company.ID))
                {
                    db.CompanyCountries.RemoveRange(db.CompanyCountries.Where(cc => cc.CompanyId == user.Company.ID));
                    await db.SaveChangesAsync();
                }

                List <CompanyCountry> countries = new List <CompanyCountry>();
                foreach (string country in companyProfileDTO.Countries)
                {
                    var countryModel = db.Countries.SingleOrDefault(c => c.Name == country);
                    if (countryModel != null)
                    {
                        CompanyCountry companyCountry = new CompanyCountry();
                        companyCountry.CompanyId = user.Company.ID;
                        companyCountry.CountryId = countryModel.Id;
                        countries.Add(companyCountry);
                    }
                }
                db.CompanyCountries.AddRange(countries);
                await db.SaveChangesAsync();
            }

            if (!db.Sectors.Any(s => s.SectorName == companyProfileDTO.Sector))
            {
                Sector sector = new Sector();
                sector.Active     = true;
                sector.CreateDate = DateTime.Now;
                sector.SectorName = companyProfileDTO.Sector;
                db.Sectors.Add(sector);
                await db.SaveChangesAsync();
            }

            bool existingSkills = db.CompanySkills.Any(cs => cs.CompanyId == user.Company.ID);

            if (existingSkills)
            {
                //remove it
                List <CompanySkill> companySkills = db.CompanySkills.Where(cs => cs.CompanyId == user.Company.ID).ToList();
                db.CompanySkills.RemoveRange(companySkills);
                db.SaveChanges();
            }


            if (companyProfileDTO.Skills != null && companyProfileDTO.Skills.Count() > 0 && user.Company.ID > 0)
            {
                bool hasSkill = false;
                foreach (string skill in companyProfileDTO.Skills)
                {
                    CompanySkill existing = db.CompanySkills.SingleOrDefault(cs => cs.SkillName == skill && cs.CompanyId == user.Company.ID);
                    if (existing == null)
                    {
                        if (!db.Skills.Any(s => s.SkillName == skill))
                        {
                            Skill skillMaster = new Skill();
                            skillMaster.SkillName  = skill;
                            skillMaster.Active     = true;
                            skillMaster.CreateDate = DateTime.Now;
                            db.Skills.Add(skillMaster);
                            db.SaveChanges();
                        }
                        CompanySkill newSkill = new CompanySkill();
                        newSkill.CompanyId = user.Company.ID;
                        newSkill.SkillName = skill;
                        db.CompanySkills.Add(newSkill);
                        hasSkill = true;
                    }
                }
                if (hasSkill)
                {
                    await db.SaveChangesAsync();
                }
            }

            if (!user.OnboardingSkipped)
            {
                List <CompanyMember> companyMembers = await db.CompanyMembers.Where(c1 => c1.UserID == user.Id).ToListAsync();

                if (companyMembers != null && companyMembers.Count > 0)
                {
                    CompanyMember cm = companyMembers.FirstOrDefault();
                    if (cm != null)
                    {
                        db.CompanyMembers.Remove(cm);
                        await db.SaveChangesAsync();
                    }
                }
            }


            return(Ok(Mapper.Map <Company, CompanyProfileDTO>(user.Company)));
        }
コード例 #3
0
        public APIGatewayProxyResponse SaveCompany(APIGatewayProxyRequest request, ILambdaContext context)
        {
            try
            {
                context.Logger.LogLine("Get Request\n");

                if (!ValidateRequest(request))
                {
                    return(new APIGatewayProxyResponse
                    {
                        StatusCode = (int)HttpStatusCode.Forbidden,
                        Headers = new Dictionary <string, string> {
                            { "Content-Type", "text/plain" }
                        }
                    });
                }

                if (string.IsNullOrEmpty(request.Body))
                {
                    throw new ArgumentNullException("request.Body");
                }

                Company source = JsonConvert.DeserializeObject <Company>(request.Body);

                Company       targetCompany;
                SilverContext silverContext = new SilverContext();
                if (!source.Id.HasValue || source.Id == 0)
                {
                    targetCompany = new Company();
                    silverContext.Companies.Add(targetCompany);
                }
                else
                {
                    targetCompany = silverContext.Companies.Where(x => x.Id == source.Id)
                                    .Include(x => x.CompanyCountries)
                                    .Include(x => x.CompanyExtendedData)
                                    .Include(x => x.CompanyQuestionnaires)
                                    .Include(x => x.CompanyIndustries)
                                    .Include(x => x.CompanyNames)
                                    .FirstOrDefault();

                    if (targetCompany == null)
                    {
                        throw new ArgumentOutOfRangeException("company");
                    }
                }

                targetCompany.Lei          = source.Lei;
                targetCompany.Status       = source.Status;
                targetCompany.LegalName    = source.LegalName;
                targetCompany.NumEmployees = source.NumEmployees;

                // countries

                var srcIds = source.CompanyCountries
                             .Where(x => x.CompanyCountryId.HasValue)
                             .Select(x => x.CompanyCountryId.Value)
                             .ToHashSet();

                var toRemove = new List <CompanyCountry>();
                foreach (var companyCountry in targetCompany.CompanyCountries)
                {
                    if (!srcIds.Contains(companyCountry.CompanyCountryId.Value))
                    {
                        toRemove.Add(companyCountry);
                    }
                }
                foreach (var item in toRemove)
                {
                    targetCompany.CompanyCountries.Remove(item);
                    silverContext.Remove(item);
                }

                foreach (var companyCountry in source.CompanyCountries)
                {
                    CompanyCountry targetEntity;
                    if (!companyCountry.CompanyCountryId.HasValue)
                    {
                        targetEntity = new CompanyCountry()
                        {
                            Company = targetCompany
                        };

                        targetCompany.CompanyCountries.Add(targetEntity);
                        silverContext.CompanyCountries.Add(targetEntity);
                    }
                    else
                    {
                        targetEntity = targetCompany.CompanyCountries.First(x => x.CompanyCountryId == companyCountry.CompanyCountryId);
                    }
                    targetEntity.CountryId         = companyCountry.CountryId;
                    targetEntity.IsPrimary         = companyCountry.IsPrimary;
                    targetEntity.LegalJurisdiction = companyCountry.LegalJurisdiction;
                    targetEntity.Ticker            = companyCountry.Ticker;
                }

                // extended data
                if (source.CompanyExtendedData.Count > 0)
                {
                    var sourceExtendedData = source.CompanyExtendedData.First();
                    CompanyExtendedData targetExtendedData;
                    if (targetCompany.CompanyExtendedData.Any())
                    {
                        targetExtendedData = targetCompany.CompanyExtendedData.First();
                    }
                    else
                    {
                        targetExtendedData = new CompanyExtendedData();
                        targetCompany.CompanyExtendedData.Add(targetExtendedData);
                        silverContext.Add(targetExtendedData);
                    }
                    targetExtendedData.BelowNationalAvgIncome = sourceExtendedData.BelowNationalAvgIncome;
                    targetExtendedData.Company           = targetCompany;
                    targetExtendedData.DisabledEmployees = sourceExtendedData.DisabledEmployees;
                    targetExtendedData.HierarchyLevel    = sourceExtendedData.HierarchyLevel;
                    targetExtendedData.RetentionRate     = sourceExtendedData.RetentionRate;
                    targetExtendedData.MedianSalary      = sourceExtendedData.MedianSalary;
                }
                else
                {
                    targetCompany.CompanyExtendedData.Clear();
                }

                // questions
                if (source.CompanyQuestionnaires.Count > 0)
                {
                    srcIds = source.CompanyQuestionnaires
                             .Where(x => x.Id.HasValue)
                             .Select(x => x.Id.Value)
                             .ToHashSet();

                    var questionsToRemove = new List <CompanyQuestion>();
                    foreach (var companyQuestion in targetCompany.CompanyQuestionnaires)
                    {
                        if (!srcIds.Contains(companyQuestion.Id.Value))
                        {
                            questionsToRemove.Add(companyQuestion);
                        }
                    }
                    foreach (var item in questionsToRemove)
                    {
                        targetCompany.CompanyQuestionnaires.Remove(item);
                        silverContext.Remove(item);
                    }

                    foreach (var companyQuestion in source.CompanyQuestionnaires)
                    {
                        CompanyQuestion targetEntity;
                        if (!companyQuestion.Id.HasValue)
                        {
                            targetEntity = new CompanyQuestion()
                            {
                                Company = targetCompany
                            };

                            targetCompany.CompanyQuestionnaires.Add(targetEntity);
                            silverContext.CompanyQuestionnaires.Add(targetEntity);
                        }
                        else
                        {
                            targetEntity = targetCompany.CompanyQuestionnaires.First(x => x.Id == companyQuestion.Id);
                        }
                        targetEntity.Question = companyQuestion.Question;
                        targetEntity.Answer   = companyQuestion.Answer;
                    }
                }
                else
                {
                    targetCompany.CompanyQuestionnaires.Clear();
                }

                // names
                if (source.CompanyNames.Count > 0)
                {
                    srcIds = source.CompanyNames
                             .Where(x => x.Id.HasValue)
                             .Select(x => x.Id.Value)
                             .ToHashSet();

                    var namesToRemove = new List <CompanyName>();
                    foreach (var companyName in targetCompany.CompanyNames)
                    {
                        if (!srcIds.Contains(companyName.Id.Value))
                        {
                            namesToRemove.Add(companyName);
                        }
                    }
                    foreach (var item in namesToRemove)
                    {
                        targetCompany.CompanyNames.Remove(item);
                        silverContext.Remove(item);
                    }

                    foreach (var companyName in source.CompanyNames)
                    {
                        CompanyName targetEntity;
                        if (!companyName.Id.HasValue)
                        {
                            targetEntity = new CompanyName()
                            {
                                Company = targetCompany
                            };

                            targetCompany.CompanyNames.Add(targetEntity);
                            silverContext.CompanyNames.Add(targetEntity);
                        }
                        else
                        {
                            targetEntity = targetCompany.CompanyNames.First(x => x.Id == companyName.Id);
                        }
                        targetEntity.Name = companyName.Name;
                        targetEntity.Type = companyName.Type;
                    }
                }
                else
                {
                    targetCompany.CompanyNames.Clear();
                }

                // industries
                if (source.CompanyIndustries.Count > 0)
                {
                    srcIds = source.CompanyIndustries
                             .Where(x => x.Id.HasValue)
                             .Select(x => x.Id.Value)
                             .ToHashSet();

                    var industriesToRemove = new List <CompanyIndustry>();
                    foreach (var companyName in targetCompany.CompanyIndustries)
                    {
                        if (!srcIds.Contains(companyName.Id.Value))
                        {
                            industriesToRemove.Add(companyName);
                        }
                    }
                    foreach (var item in industriesToRemove)
                    {
                        targetCompany.CompanyIndustries.Remove(item);
                        silverContext.Remove(item);
                    }

                    foreach (var companyIndustry in source.CompanyIndustries)
                    {
                        CompanyIndustry targetEntity;
                        if (!companyIndustry.Id.HasValue)
                        {
                            targetEntity = new CompanyIndustry()
                            {
                                Company = targetCompany
                            };

                            targetCompany.CompanyIndustries.Add(targetEntity);
                            silverContext.CompanyIndustries.Add(targetEntity);
                        }
                        else
                        {
                            targetEntity = targetCompany.CompanyIndustries.First(x => x.Id == companyIndustry.Id);
                        }
                        targetEntity.IndustryId       = companyIndustry.IndustryId;
                        targetEntity.PrimarySecondary = companyIndustry.PrimarySecondary;
                    }
                }
                else
                {
                    targetCompany.CompanyIndustries.Clear();
                }

                // TODO: roles and people

                silverContext.SaveChanges();

                var response = new APIGatewayProxyResponse
                {
                    StatusCode = (int)HttpStatusCode.OK,
                    Headers    = new Dictionary <string, string> {
                        { "Content-Type", "text/plain" }
                    }
                };

                return(response);
            }
            catch (Exception ex)
            {
                return(new APIGatewayProxyResponse
                {
                    StatusCode = (int)HttpStatusCode.BadRequest,
                    Body = $"Bad query: {ex}",
                    Headers = new Dictionary <string, string> {
                        { "Content-Type", "text/plain" }
                    }
                });
            }
        }