public async Task <CompanyMember> UpdateAsync(CompanyMember companyMember, CancellationToken token)
{
_context.CompanyMembers.Update(companyMember);
await _context.SaveChangesAsync(token);
return(companyMember);
}
public async Task <IHttpActionResult> RemoveMemberFromMyCompany(CompanyMemberDTO companyMemberDTO)
{
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));
}
Company company = authenticatedUser.Company;
if (company == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
CompanyMember companyMember = db.CompanyMembers.Where(_companyMember => _companyMember.UserID == companyMemberDTO.UserID && _companyMember.CompanyID == company.ID).SingleOrDefault();
if (companyMember == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
db.CompanyMembers.Remove(companyMember);
await db.SaveChangesAsync();
return(Ok());
}
public override CompanyMember ToCompanyMember(CompanyMember companyMember, string memberId)
{
var retVal = base.ToCompanyMember(companyMember, memberId);
retVal.IsActive = true;
return(retVal);
}
public async Task <bool> AddCompany(CompanyViewModel objCompanyViewModel)
{
var objCompany = new Company
{
Name = objCompanyViewModel.Name,
Address = objCompanyViewModel.Address,
City = objCompanyViewModel.City,
Country = objCompanyViewModel.Country,
Email = objCompanyViewModel.Email,
MobileNo = objCompanyViewModel.MobileNo,
State = objCompanyViewModel.State,
CreatedBy = objCompanyViewModel.CreatedBy,
CreatedDate = DateTime.Now
};
this.entities.Companies.Add(objCompany);
await this.entities.SaveChangesAsync();
var objCompanyMember = new CompanyMember
{
UserId = objCompanyViewModel.CreatedBy,
CompanyId = objCompany.Id,
CreatedDate = DateTime.Now
};
this.entities.CompanyMembers.Add(objCompanyMember);
await this.entities.SaveChangesAsync();
return(true);
}
public List <ProductSummaryDTO> GetProductSharedByCompany(long companyId)
{
string userName = User.Identity.Name;
User user = db.Users.Where(_user => _user.UserName == userName).AsNoTracking().SingleOrDefault();
if (user == null)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
if (!db.Companies.Any(c => c.ID == companyId))
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
bool isUserAssociatedWithCompany = false;
if (db.CompanyMembers.Any(cm => cm.CompanyID == companyId && cm.UserID == user.Id))
{
isUserAssociatedWithCompany = true;
}
if (isUserAssociatedWithCompany)
{
CompanyMember companyMember = db.CompanyMembers.SingleOrDefault(cm => cm.CompanyID == companyId && cm.UserID == user.Id);
IQueryable <Product> products = db.Products.Where(p => p.CompanyID == companyMember.CompanyID && p.TeamMembers.Select(c => c.UserID).Contains(user.Id)).Include(p => p.TeamMembers);
return(products.ProjectTo <ProductSummaryDTO>().ToList());
}
return(new List <ProductSummaryDTO>());
}
public IHttpActionResult UpdateMember(CompanyMember companyMember)
{
// Request company member by id to prevent security violation when someone can pass wrong security account to company member model
var requestedCompanyMember = _memberService.GetByIds(new [] { companyMember.Id }).Cast <CompanyMember>().FirstOrDefault();
CheckCurrentUserHasPermissionForCompanyMember(requestedCompanyMember?.SecurityAccounts.Select(x => x.UserName));
_memberService.SaveChanges(new[] { companyMember });
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <CompanyMember> AddAsync(CompanyMember companyMember, CancellationToken token)
{
companyMember.Id = 0;
_context.CompanyMembers.Add(companyMember);
await _context.SaveChangesAsync(token);
return(companyMember);
}
public override CompanyMember ToCompanyMember(CompanyMember companyMember, string memberId)
{
var retVal = base.ToCompanyMember(companyMember, memberId);
retVal.Organizations = new List <string> {
CompanyId
};
return(retVal);
}
public async Task <IHttpActionResult> AddNewMemberToMyCompany(NewCompanyMemberDTO newCompanyMemberDTO)
{
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.Where(_user => _user.UserName == newCompanyMemberDTO.UserName).SingleOrDefault();
if (user == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
Company company = authenticatedUser.Company;
if (company == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
CompanyMember companyMember = db.CompanyMembers.Where(_companyMember => _companyMember.UserID == user.Id && _companyMember.CompanyID == company.ID).SingleOrDefault();
if (companyMember != null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
UserLevel editorUserLevel = await db.UserLevels.SingleOrDefaultAsync(ul => ul.Name == "Editor");
companyMember = new CompanyMember();
companyMember.UserID = user.Id;
companyMember.CompanyID = company.ID;
companyMember.User = user;
companyMember.Company = authenticatedUser.Company;
companyMember.Role = newCompanyMemberDTO.Role;
if (editorUserLevel != null)
{
companyMember.UserLevelId = editorUserLevel.Id;
}
companyMember = db.CompanyMembers.Add(companyMember);
await db.SaveChangesAsync();
return(Ok(Mapper.Map <CompanyMember, CompanyMemberDTO>(companyMember)));
}
public async Task <IHttpActionResult> GetCompanyMember(int id)
{
CompanyMember companyMember = await db.CompanyMembers.FindAsync(id);
if (companyMember == null)
{
return(NotFound());
}
return(Ok(companyMember));
}
public virtual CompanyMember ToCompanyMember(CompanyMember companyMember, string memberId)
{
companyMember.Id = memberId;
companyMember.Name = $"{FirstName} {LastName}";
companyMember.FullName = $"{FirstName} {LastName}";
companyMember.FirstName = FirstName;
companyMember.LastName = LastName;
companyMember.Title = Title;
companyMember.Emails = new[] { Email };
return(companyMember);
}
public InviteValidator(IMemberService memberService)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
CompanyMember member = null;
RuleFor(x => x.Value).NotEmpty()
.Must(i => (member = memberService.GetByIds(new[] { i }).OfType <CompanyMember>().SingleOrDefault()) != null)
.WithMessage(B2BExtensionsResources.InvalidInvite)
.Must(i => !member.SecurityAccounts.Any())
.WithMessage(B2BExtensionsResources.InviteAlreadyUsed);
}
public async Task <ActionResult> Edit([Bind(Include = "CompanyMemberID,Name,JobTitle,Message")] CompanyMember companyMember)
{
if (ModelState.IsValid)
{
db.Entry(companyMember).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.CompanyMemberID = new SelectList(db.CompanyMemberImages, "CompanyMemberImageId", "Title", companyMember.CompanyMemberID);
return(View(companyMember));
}
public IQueryable <ProductDTO> GetMyCompanyProducts()
{
string userName = User.Identity.Name;
User user = db.Users.Where(_user => _user.UserName == userName).AsNoTracking().SingleOrDefault();
if (user == null)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
if (user.Company != null)
{
IQueryable <Product> products = db.Products.Where(product => product.Company.Owner.Id == user.Id)
.Include(product => product.GroupsVisibleTo);
return(products.ProjectTo <ProductDTO>());
}
if (user.IsIndividual.HasValue && user.IsIndividual.Value)
{
IQueryable <Product> products = db.Products.Where(product => product.Company.Owner.Id == user.Id)
.Include(product => product.GroupsVisibleTo);
IQueryable <Product> myProducts = db.Products.Where(product => product.UserId.HasValue && product.UserId.Value == user.Id && !product.CompanyID.HasValue)
.Include(product => product.GroupsVisibleTo);
return(products.Concat(myProducts).ProjectTo <ProductDTO>());
}
else if (user.IsIndividual == false && user.Company == null)
{
if (!user.OnboardingSkipped)
{
CompanyMember companyMember = db.CompanyMembers.Where(cm => cm.UserID == user.Id).FirstOrDefault();
if (companyMember != null)
{
try
{
IQueryable <Product> myProducts = db.Products.Where(product => product.UserId.HasValue && product.CompanyID.HasValue && product.UserId.Value == user.Id && companyMember.CompanyID == product.CompanyID);
return(myProducts.ProjectTo <ProductDTO>());
}
catch (Exception x)
{
//todo: need to log error
}
}
}
else
{
IQueryable <Product> myProducts = db.Products.Where(product => product.UserId.HasValue && product.UserId.Value == user.Id);
return(myProducts.ProjectTo <ProductDTO>());
}
}
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
public async Task <ActionResult> Create([Bind(Include = "CompanyMemberId,Name,JobTitle,Message,ContactURL")] CompanyMember companyMember)
{
if (ModelState.IsValid)
{
db.CompanyMembers.Add(companyMember);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.CompanyMemberId = new SelectList(db.CompanyMemberPhotoes, "CompanyMemberPhotoId", "FileName", companyMember.CompanyMemberId);
return(View(companyMember));
}
// GET: CompanyMembers/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CompanyMember companyMember = await db.CompanyMembers.FindAsync(id);
if (companyMember == null)
{
return(HttpNotFound());
}
return(View(companyMember));
}
public async Task <bool> AddCompanyMember(CompanyMemberViewModel objCompanyMemberViewModel)
{
var objCompanyMember = new CompanyMember
{
UserId = objCompanyMemberViewModel.UserId,
CompanyId = objCompanyMemberViewModel.CompanyId,
CreatedDate = DateTime.Now
};
this.entities.CompanyMembers.Add(objCompanyMember);
await this.entities.SaveChangesAsync();
return(true);
}
// GET: CompanyMembers/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CompanyMember companyMember = await db.CompanyMembers.FindAsync(id);
if (companyMember == null)
{
return(HttpNotFound());
}
ViewBag.CompanyMemberID = new SelectList(db.CompanyMemberImages, "CompanyMemberImageId", "Title", companyMember.CompanyMemberID);
return(View(companyMember));
}
public virtual CompanyMember ToCompanyMember(CompanyMember companyMember, string memberId)
{
companyMember.Id = memberId;
companyMember.Name = $"{FirstName} {LastName}";
companyMember.FullName = $"{FirstName} {LastName}";
companyMember.FirstName = FirstName;
companyMember.LastName = LastName;
companyMember.IsActive = IsActive;
companyMember.Title = Title;
companyMember.Emails = new[] { Email };
Address.FirstName = FirstName;
Address.LastName = LastName;
companyMember.Addresses = new[] { Address };
companyMember.Phones = new[] { Address.Phone };
return(companyMember);
}
public IHttpActionResult GetCompanyMemberLevelByCompanyId(long companyId)
{
string userName = User.Identity.Name;
User user = db.Users.Where(_user => _user.UserName == userName).SingleOrDefault();
if (user == null)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
CompanyMember companyMember = db.CompanyMembers.Where(cm => cm.CompanyID == companyId && cm.UserID == user.Id).FirstOrDefault();
if (companyMember != null && companyMember.UserLevelId.HasValue && companyMember.UserLevelId.Value > 0)
{
return(Ok(Mapper.Map <CompanyMember, CompanyMemberDTO>(companyMember)));
}
throw new HttpResponseException(HttpStatusCode.NotFound);
}
public static Result CheckMemberExist(string patientGUID)
{
Result result = new Result();
MMOverride db = null;
try
{
db = new MMOverride();
CompanyMember m = db.CompanyMembers.SingleOrDefault <CompanyMember>(mm => mm.PatientGUID.ToString() == patientGUID &&
mm.Status == (byte)Status.Actived &&
mm.Company.Status == (byte)Status.Actived);
if (m == null)
{
result.Error.Code = ErrorCode.NOT_EXIST;
}
else
{
result.Error.Code = ErrorCode.EXIST;
}
}
catch (System.Data.SqlClient.SqlException se)
{
result.Error.Code = (se.Message.IndexOf("Timeout expired") >= 0) ? ErrorCode.SQL_QUERY_TIMEOUT : ErrorCode.INVALID_SQL_STATEMENT;
result.Error.Description = se.ToString();
}
catch (Exception e)
{
result.Error.Code = ErrorCode.UNKNOWN_ERROR;
result.Error.Description = e.ToString();
}
finally
{
if (db != null)
{
db.Dispose();
db = null;
}
}
return(result);
}
public async Task <IActionResult> Create(CreateVm createVm, CancellationToken token)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = createVm.Email,
Email = createVm.Email,
//extended properties
FirstName = createVm.FirstName,
LastName = createVm.LastName,
AvatarURL = "/images/user.png",
DateRegistered = DateTime.UtcNow.ToString(),
Position = "",
NickName = "",
};
var result = await _userManager.CreateAsync(user, createVm.Password);
if (result.Succeeded)
{
var companyMember = new CompanyMember
{
Company = await GetCompany(token),
UserId = user.Id,
Role = MemberRole.Administrator
};
await _companyMemberRepository.AddAsync(companyMember, CancellationToken.None);
return(RedirectToAction("Index"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(createVm));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
CompanyMember companyMember = await db.CompanyMembers.FindAsync(id);
//delete member image id existed
if (companyMember.CompanyMemberImage != null)
{
//delete image file first
PhotoFileManager manager = new PhotoFileManager(PhotoManagerType.Member);
manager.Delete(companyMember.CompanyMemberImage.FileName, false);
//delete image from db
db.CompanyMemberImages.Remove(companyMember.CompanyMemberImage);
}
db.CompanyMembers.Remove(companyMember);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
CompanyMember companyMember = await db.CompanyMembers.FindAsync(id);
//delete member profile photo first if existed
if (companyMember.CompanyMemberPhoto != null)
{
PhotoFileManager manager = new PhotoFileManager(PhotoManagerType.Member);
manager.Delete(companyMember.CompanyMemberPhoto.FileName, false);
//delete photo second
db.CompanyMemberPhotoes.Remove(companyMember.CompanyMemberPhoto);
}
db.CompanyMembers.Remove(companyMember);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <IHttpActionResult> UpdateMemberOfMyCompany(CompanyMemberUpdateDTO companyMemberUpdateDTO)
{
string userName = User.Identity.Name;
User user = db.Users.Where(_user => _user.UserName == userName).SingleOrDefault();
if (user == null)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CompanyMember companyMember = db.CompanyMembers.Where(_companyMember => _companyMember.ID == companyMemberUpdateDTO.ID).SingleOrDefault();
if (companyMember == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
Company company = user.Company;
if (company == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
if (companyMember.Company != company)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
companyMember.UserLevelId = companyMemberUpdateDTO.UserLevelId;
companyMember.Role = companyMemberUpdateDTO.Role;
companyMember.Email = companyMemberUpdateDTO.Email;
db.Entry(companyMember).State = EntityState.Modified;
await db.SaveChangesAsync();
return(Ok(Mapper.Map <CompanyMember, CompanyMemberDTO>(companyMember)));
}
private async Task CreateCompany(string name)
{
var company = new Company
{
Name = name,
AccentColorFirst = "#ff55a5",
AccentColorSecond = "#ff5860"
};
company = await _companyRepository.AddAsync(company, CancellationToken.None);
var user = await _userManager.FindByIdAsync(_userManager.GetUserId(User)) as IdentityUser;
var companyMember = new CompanyMember
{
Company = company,
UserId = user.Id,
Role = MemberRole.Administrator
};
await _companyMemberRepository.AddAsync(companyMember, CancellationToken.None);
}
public async Task <IHttpActionResult> NewProduct(NewProductDTO newProductDTO)
{
string userName = User.Identity.Name;
User user = db.Users.Where(_user => _user.UserName == userName).SingleOrDefault();
if (user == null)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Company company = user.Company;
Product product = new Product();
ProductUpdate productUpdate = new ProductUpdate();
Regex regex = new Regex("[^a-zA-Z0-9_-]");
product.URI = regex.Replace(newProductDTO.Name, "").ToLower();
if (product.URI.Length == 0)
{
product.URI = null;
}
else if (company != null && db.Products.Where(_product => _product.URI == product.URI && _product.CompanyID == company.ID).SingleOrDefault() != null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
if (company != null)
{
product.CompanyID = company.ID;
product.Company = company;
product.User = null;
}
else if (user.IsIndividual.HasValue && user.IsIndividual.Value)
{
product.UserId = user.Id;
product.User = user;
product.Company = null;
}
else
{
CompanyMember companyMember = await db.CompanyMembers.Where(cm => cm.UserID == user.Id).FirstOrDefaultAsync();
if (companyMember != null)
{
product.CompanyID = companyMember.CompanyID;
product.UserId = user.Id;
product.Company = null;
}
}
product.Name = newProductDTO.Name;
product.Description = newProductDTO.Description;
product.Privacy = newProductDTO.Privacy;
product.Logo = newProductDTO.Logo;
if (newProductDTO.Privacy == ProductPrivacy.VisibleToSelectedGroups)
{
foreach (CompanyFollowerGroupDTO companyFollowerGroupDto in newProductDTO.GroupsVisibleTo)
{
product.GroupsVisibleTo.Add(db.CompanyFollowerGroups.Where(followerGroup => followerGroup.ID == companyFollowerGroupDto.ID && followerGroup.CompanyID == company.ID).SingleOrDefault());
}
}
product = db.Products.Add(product);
productUpdate.UserID = user.Id;
productUpdate.User = user;
productUpdate.ProductID = product.ID;
productUpdate.Product = product;
productUpdate.DateTime = DateTime.Now;
productUpdate.UpdateType = UpdateType.ProductAdded;
db.ProductUpdates.Add(productUpdate);
await db.SaveChangesAsync();
return(Ok(Mapper.Map <Product, ProductDTO>(product)));
}
public async Task <IHttpActionResult> ConfirmEmail(long userId, string confirmationToken)
{
if (string.IsNullOrWhiteSpace(confirmationToken) == true)
{
return(BadRequest("Confirmation token is required."));
}
string webSiteUrl = System.Configuration.ConfigurationManager.AppSettings["WebSiteUrl"];
try
{
User user = this._authenticationRepository.GetDbContext().Users.Where(u => u.Id == userId).SingleOrDefault();
if (user != null)
{
bool isConfirmed = await this._authenticationRepository.IsEmailConfirmedAsync(userId);
if (isConfirmed == false)
{
byte[] urlDecodedConfirmationTokenBytes = HttpServerUtility.UrlTokenDecode(confirmationToken);
string urlDecodedConfirmationToken = Encoding.UTF8.GetString(urlDecodedConfirmationTokenBytes);
IdentityResult result = await this._authenticationRepository.ConfirmEmailAsync(userId, urlDecodedConfirmationToken);
if (!result.Succeeded)
{
return(this.GetErrorResult(result));
}
InviteRequest inviteRequest = inviteRequestService.GetByInviteEmailAddress(user.Email);
if (inviteRequest != null)
{
User inviteFromUser = this._authenticationRepository.GetDbContext().Users.SingleOrDefault(c => c.Id == inviteRequest.InviteFromUserId);
if (inviteFromUser != null)
{
CompanyMember companyMember = this._authenticationRepository.GetDbContext().CompanyMembers.Where(_companyMember => _companyMember.UserID == user.Id && _companyMember.CompanyID == inviteFromUser.Company.ID).SingleOrDefault();
if (companyMember == null)
{
companyMember = new CompanyMember();
companyMember.UserID = user.Id;
companyMember.CompanyID = inviteFromUser.Company.ID;
companyMember.User = user;
companyMember.Company = inviteFromUser.Company;
companyMember.Role = "";
companyMember = this._authenticationRepository.GetDbContext().CompanyMembers.Add(companyMember);
inviteRequest.Processed = true;
this._authenticationRepository.GetDbContext().Entry(inviteRequest).State = EntityState.Modified;
await this._authenticationRepository.GetDbContext().SaveChangesAsync();
}
}
}
}
else
{
return(Redirect(string.Format("{0}/emailalreadyconfirmed", webSiteUrl)));
}
}
else
{
return(BadRequest("Invalid user."));
}
}
catch (Exception)
{
return(BadRequest());
}
return(Redirect(string.Format("{0}/confirmemail", webSiteUrl)));
//return Redirect("http://localhost:53009/confirmemail");
}
public async Task <IHttpActionResult> AddNewProductTeamMember(NewProductTeamMemberDTO newProductTeamMemberDTO)
{
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));
}
Product product = db.Products.Where(_product => _product.ID == newProductTeamMemberDTO.ProductID)
.Include(_product => _product.TeamMembers
.Select(teamMember => teamMember.User)
.Select(teamMember => teamMember.Company))
.SingleOrDefault();
if (product == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
if ((product.CompanyID != authenticatedUser.Company.ID) && (product.TeamMembers.Where(teamMember => teamMember.UserID == authenticatedUser.Id && teamMember.CanEditTheProduct == true).SingleOrDefault() == null))
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
User productTeamMemberUser = db.Users.Where(_user => _user.Id == newProductTeamMemberDTO.UserID)
.Include(_user => _user.CompaniesAsMembers)
.Include(_user => _user.ProductTeamMembers)
.SingleOrDefault();
if (productTeamMemberUser == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
Company company = product.Company;
if (company == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
CompanyMember companyMember = productTeamMemberUser.CompaniesAsMembers.Where(_companyMember => _companyMember.CompanyID == company.ID).SingleOrDefault();
if (companyMember == null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
ProductTeamMember productTeamMember = productTeamMemberUser.ProductTeamMembers.Where(_productTeamMember => _productTeamMember.ProductID == newProductTeamMemberDTO.ProductID).SingleOrDefault();
if (productTeamMember != null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
productTeamMember = new ProductTeamMember();
productTeamMember.UserID = productTeamMemberUser.Id;
productTeamMember.ProductID = product.ID;
productTeamMember.User = productTeamMemberUser;
productTeamMember.Product = product;
productTeamMember.CanEditTheProduct = false;
productTeamMember = db.ProductTeamMembers.Add(productTeamMember);
await db.SaveChangesAsync();
return(Ok(Mapper.Map <ProductTeamMember, ProductTeamMemberDTO>(productTeamMember)));
}
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)));
}
