// POST api/projects public IHttpActionResult Post([FromBody] ProjectDTO value) { var project = Mapper.Map <Project>(value); project.Organisation = null; if (CurrentUser is OrgUser) { project.OrganisationId = CurrentOrgUser.OrganisationId.Value; } else if (CurrentUser is SuperUser) { if (value.Organisation == null) { return(BadRequest("Organisation is required")); } project.OrganisationId = Guid.Parse(value.Organisation.Id); } try { UnitOfWork.ProjectsRepository.InsertOrUpdate(project); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult DeleteRelationship(Guid datalistId, Guid id) { var owner = UnitOfWork.DataListsRepository.Find(datalistId); if (owner == null || owner.OrganisationId != CurrentOrganisationId) { return(NotFound()); } var relationship = UnitOfWork.DataListRelationshipsRepository.Find(id); if (relationship == null || relationship.OwnerId != datalistId) { return(NotFound()); } try { UnitOfWork.DataListRelationshipsRepository.Delete(relationship); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult Delete(Guid formTemplateId, Guid id) { if (formTemplateId == Guid.Empty) return BadRequest("form template id is empty"); if (id == Guid.Empty) return BadRequest("metric id is empty"); var metric = GetMetric(formTemplateId, id); if (metric == null) NotFound(); try { UnitOfWork.MetricsRepository.Delete(metric); UnitOfWork.MetricsRepository.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return Ok(); } catch (Exception ex) { return InternalServerError(ex); } }
// DEL api/formTemplateCategories/{id} public IHttpActionResult Delete(Guid id) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var item = UnitOfWork.FormTemplateCategoriesRepository .AllAsNoTracking .Where(c => c.Id == id && c.OrganisationId == CurrentOrgUser.OrganisationId) .SingleOrDefault(); if (item == null) { return(NotFound()); } try { UnitOfWork.FormTemplateCategoriesRepository.Delete(item); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
// POST api/organisations public IHttpActionResult Post([FromBody] OrganisationDTO value) { var createOrganisation = new CreateOrganisation(); createOrganisation.Name = value.Name; createOrganisation.RootUserEmail = value.RootUser.Email; createOrganisation.RootUserFirstName = value.RootUser.FirstName; createOrganisation.RootUserSurname = value.RootUser.Surname; createOrganisation.RootPassword = value.RootUser.Password; createOrganisation.RootConfirmPassword = value.RootUser.ConfirmPassword; createOrganisation.AddressLine1 = value.AddressLine1; createOrganisation.AddressLine2 = value.AddressLine2; createOrganisation.County = value.County; createOrganisation.Town = value.Town; createOrganisation.Postcode = value.Postcode; createOrganisation.TelNumber = value.TelNumber; createOrganisation.DefaultCalendarId = CalendarsRepository.Gregorian.Id; createOrganisation.DefaultLanguageId = LanguagesRepository.English.Id; Organisations.CreateOrganisation(createOrganisation); try { UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult DeleteAssignments(Guid userId, EmailNotificationType flag) { if (userId == Guid.Empty) { return(BadRequest("user id is empty")); } var recipient = UnitOfWork.EmailRecipientsRepository .AllAsNoTracking .SingleOrDefault(x => x.OrgUserId == userId); if (recipient == null) { return(NotFound()); } var entry = UnitOfWork.EmailRecipientsRepository.AssignEmailNotification(userId, flag, enabled: false); if (entry != null) { var result = Mapper.Map <EmailRecipientDTO>(entry); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok(result)); } return(Ok(new EmailRecipientDTO())); }
public IHttpActionResult Put(Guid id, [FromBody] OrgInvitationDTO value) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var invitation = UnitOfWork.OrgInvitationsRepository.Find(id); if (invitation == null) { return(NotFound()); } invitation.Name = value.Name; invitation.Token = value.Token; invitation.Limit = value.Limit; invitation.IsActive = value.IsActive; invitation.OrganisationId = Guid.Parse(value.Organisation.Id); try { UnitOfWork.OrgInvitationsRepository.InsertOrUpdate(invitation); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult Post([FromBody] OrgInvitationDTO value) { var invitation = Mapper.Map <OrganisationInvitation>(value); if (CurrentUser is OrgUser) { invitation.Organisation = CurrentOrgUser.Organisation; } else { invitation.OrganisationId = Guid.Parse(value.Organisation.Id); invitation.Organisation = null; } UnitOfWork.OrgInvitationsRepository.InsertOrUpdate(invitation); try { UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (DbUpdateException) { return(BadRequest("cannot create duplicate invitation tokens")); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult AssignUsers(Guid id, OrganisationAssignmentDTO model) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var org = Organisations.Find(id); if (org == null) { return(NotFound()); } var subscriptionService = new SubscriptionService(UnitOfWork); subscriptionService.MoveUsersToOrganisation(org, model.OrgUsers); try { // TODO: notify the user by email. // notify orgUser about joining organisation // notify orgAdmin about new user UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult Put(Guid id, FormTemplateDTO value) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var response = FormTemplatesService.Update(id, value); if (!response.Success) { if (response.Message.ToLower() == "not found") { return(NotFound()); } if (response.ValidationErrors.Any()) { return(BadRequest(response.Message)); } return(BadRequest(response.Message)); } var retVal = Mapper.Map <FormTemplateDTO>(response.ReturnValue); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok(retVal)); }
public IHttpActionResult EditBasicDetails(Guid id, EditBasicDetailsReqDTO value) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var response = FormTemplatesService.UpdateBasicDetails(id, value); if (!response.Success) { if (response.Message.ToLower() == "not found") { return(NotFound()); } if (response.ValidationErrors.Any()) { return(Content(System.Net.HttpStatusCode.BadRequest, response)); } return(BadRequest(response.Message)); } MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok(response.ReturnValue)); }
public IHttpActionResult UndoPublish(Guid id) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var response = FormTemplatesService.Unpublish(id); if (!response.Success) { if (response.Message.ToLower() == "not found") { return(NotFound()); } if (response.ValidationErrors.Any()) { return(Content(System.Net.HttpStatusCode.BadGateway, response)); } return(BadRequest(response.Message)); } MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); }
public IHttpActionResult Delete(Guid id) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var team = UnitOfWork.OrganisationTeamsRepository.Find(id); if (team == null) { return(NotFound()); } try { UnitOfWork.OrganisationTeamsRepository.Delete(team); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (DbUpdateException dbEx) { return(BadRequest("active teams cannot be deleted")); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult Post(Guid formTemplateId, MetricDTO metricDto) { if (formTemplateId == Guid.Empty) return BadRequest("form template id is empty"); var formTemplate = GetFormTemplate(formTemplateId); if (formTemplate == null) return NotFound(); var metric = Mapper.Map<Metric>(metricDto); metric.FormTemplateId = formTemplateId; try { UnitOfWork.MetricsRepository.InsertOrUpdate(metric); UnitOfWork.MetricsRepository.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return Ok(); } catch (Exception ex) { return InternalServerError(ex); } }
public IHttpActionResult Post(Guid formTemplateId, MetricGroupDTO metricGroupDto) { if (formTemplateId == Guid.Empty) { return(BadRequest("form template id is empty")); } var formTemplate = GetFormTemplate(formTemplateId); if (formTemplate == null) { return(NotFound()); } var group = Mapper.Map <MetricGroup>(metricGroupDto); group.FormTemplateId = formTemplateId; try { UnitOfWork.MetricGroupsRepository.InsertOrUpdate(group); UnitOfWork.MetricGroupsRepository.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult AddAssignments(Guid id, Guid userId, AccessLevels accessLevel) { if (id == Guid.Empty) { return(BadRequest("project id is empty")); } if (userId == Guid.Empty) { return(BadRequest("user id is empty")); } var project = UnitOfWork.ProjectsRepository.Find(id); if (project == null) { return(NotFound()); } var orgUser = UnitOfWork.OrgUsersRepository.Find(userId); if (orgUser == null) { return(NotFound()); } var assignment = UnitOfWork.AssignmentsRepository.AssignAccessLevel(id, userId, accessLevel, grant: true); var result = Mapper.Map <ProjectAssignmentDTO>(assignment); MemoryCacher.DeleteStartingWith("ORG_TEAMS_ASSIGNMENTS"); return(Ok(result)); }
// DEL api/dataLists/{id} public IHttpActionResult Delete(Guid id) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } try { UnitOfWork.DataListsRepository.Delete(id); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (DbUpdateException) { return(BadRequest("this data list cannot be deleted")); } catch (Exception ex) { return(InternalServerError(ex)); } }
public async Task <IHttpActionResult> UpdateUserStatus(Guid id, Guid userId, bool flag) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } if (userId == Guid.Empty) { return(BadRequest("user id is empty")); } var orgTeam = UnitOfWork.OrganisationTeamsRepository.Find(id); if (orgTeam == null) { return(NotFound()); } var teamUser = UnitOfWork.OrgTeamUsersRepository.Find(userId); if (teamUser == null) { return(NotFound()); } if (teamUser.OrgUser.AccountType == AccountType.MobileAccount) { return(BadRequest("Mobile users cannot become team managers!")); } teamUser.IsManager = flag; if (flag) { await UnitOfWork.UserManager.AddToRoleAsync(teamUser.OrgUserId, Role.ORG_TEAM_MANAGER); } else { await UnitOfWork.UserManager.RemoveFromRoleAsync(teamUser.OrgUserId, Role.ORG_TEAM_MANAGER); } try { UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public async Task <IHttpActionResult> AddAssignments(Guid id, OrgTeamAssignmentDTO model) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var orgTeam = UnitOfWork.OrganisationTeamsRepository.Find(id); if (orgTeam == null) { return(NotFound()); } foreach (var assignment in model.Users) { var orgUser = UnitOfWork.OrgUsersRepository.Find(assignment.OrgUserId); if (orgUser != null) { if (orgUser.Organisation.Id == orgTeam.Organisation.Id) { orgTeam.Users.Add(new OrgTeamUser { OrgUserId = orgUser.Id, OrganisationTeamId = orgTeam.Id, IsManager = assignment.IsManager }); await UnitOfWork.UserManager.AddToRoleAsync(orgUser.Id, Role.ORG_TEAM_USER); if (assignment.IsManager) { await UnitOfWork.UserManager.AddToRoleAsync(orgUser.Id, Role.ORG_TEAM_MANAGER); } // notify the orgUser by email. NotifyUserAboutJoiningTeam(orgTeam, orgUser.Email); } } } try { UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult RevokeUser(Guid id, Guid userId) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } if (userId == Guid.Empty) { return(BadRequest("user id is empty")); } var org = Organisations.Find(id); if (org == null) { return(NotFound()); } var orgUser = UnitOfWork.OrgUsersRepository.Find(userId); if (orgUser == null) { return(NotFound()); } // root users cannot be removed from an organization! if (orgUser.IsRootUser) { return(BadRequest("Root users cannot be removed from organizations!")); } var subscriptionService = new SubscriptionService(UnitOfWork); subscriptionService.RemoveUserFromOrganization(org, orgUser); try { // send email notifications NotifyUserAboutLeavingOrganisation(org.Name, orgUser.Email); NotifyOrgAdminAboutUserLeaving(org, orgUser.UserName); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); MemoryCacher.DeleteStartingWith("ORG_USERS"); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public async Task <IHttpActionResult> RemoveUser(Guid id, Guid userId) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } if (userId == Guid.Empty) { return(BadRequest("user id is empty")); } var orgTeam = UnitOfWork.OrganisationTeamsRepository.Find(id); if (orgTeam == null) { return(NotFound()); } var teamUser = UnitOfWork.OrgTeamUsersRepository.Find(userId); if (teamUser == null) { return(NotFound()); } var orgUser = UnitOfWork.OrgUsersRepository.Find(teamUser.OrgUserId); try { if (teamUser.IsManager) { await UnitOfWork.UserManager.RemoveFromRoleAsync(teamUser.OrgUserId, Role.ORG_TEAM_MANAGER); } await UnitOfWork.UserManager.RemoveFromRoleAsync(teamUser.OrgUserId, Role.ORG_TEAM_USER); UnitOfWork.OrgTeamUsersRepository.Delete(userId); // notify the orgUser by email. NotifyUserAboutLeavingTeam(orgTeam, teamUser.OrgUser.Email); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult Post(Guid organisationId) { if (CurrentOrgUser.AccountType != AccountType.MobileAccount) { return(BadRequest("connection requests can only be made by mobile users")); } if (organisationId == Guid.Empty) { return(BadRequest("organisation id is empty")); } if (CurrentOrgUser.Organisation.Id == organisationId) { return(BadRequest("you are already connected to this organisation")); } var requestCount = UnitOfWork.OrgConnectionRequestsRepository .AllAsNoTracking .Count(x => x.OrgUserId == CurrentOrgUser.Id && x.OrganisationId == organisationId); if (requestCount > 0) { return(BadRequest("you have already requested to connect to this organisation")); } var organisation = UnitOfWork.OrganisationRepository.Find(organisationId); var connectionRequest = new OrgConnectionRequest { OrgUserId = CurrentOrgUser.Id, OrganisationId = organisationId }; UnitOfWork.OrgConnectionRequestsRepository.InsertOrUpdate(connectionRequest); NotifyOnRecordAboutNewRequest(organisation.Name); NotifyOrgAdminAboutNewRequest(organisation); NotifyEmailRecipientsAboutNewRequest(organisation.Name); try { UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult Clone(Guid id, CloneReqDTO request) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var response = FormTemplatesService.Clone(id, request); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok(response.ReturnValue)); }
public IHttpActionResult Redeem(string code) { if (string.IsNullOrEmpty(code)) { return(BadRequest("voucher code is empty")); } if (CurrentOrgUser.AccountType != AccountType.MobileAccount) { return(BadRequest("vouchers are only available to mobile users")); } var result = SubscriptionService.RedeemCode(code, CurrentOrgUser); switch (result) { case RedeemCodeStatus.AlreadyRedeemed: return(BadRequest("this code has already been redeemed")); case RedeemCodeStatus.SubscriptionDisabled: return(Content(HttpStatusCode.Forbidden, "subscriptions are disabled. contact your administrator.")); case RedeemCodeStatus.SubscriptionRateNotSet: return(Content(HttpStatusCode.Forbidden, "subscription rate is not set. contact your administrator.")); case RedeemCodeStatus.SubscriptionCountLessThanOne: return(Content(HttpStatusCode.Forbidden, "invalid subscription period. contact your administrator.")); case RedeemCodeStatus.Error: return(BadRequest("an error has occured processing your code. try again or contact your administrator")); case RedeemCodeStatus.NotFound: return(NotFound()); case RedeemCodeStatus.OK: { NotifyUserAboutVoucherSubscription(); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } default: return(NotFound()); } }
// PUT api/orgTeams/{id} public IHttpActionResult Put(Guid id, [FromBody] OrganisationTeamDTO value) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var team = UnitOfWork.OrganisationTeamsRepository.Find(Guid.Parse(value.Id)); if (team == null) { return(NotFound()); } team.Name = value.Name; team.Description = value.Description; team.Colour = value.Colour; team.IsActive = value.IsActive; if (CurrentUser is OrgUser) { team.Organisation = CurrentOrgUser.Organisation; } else { if (value.Organisation == null) { return(BadRequest("organisation is required")); } team.OrganisationId = Guid.Parse(value.Organisation.Id); } try { UnitOfWork.OrganisationTeamsRepository.InsertOrUpdate(team); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
// PUT api/projects/{id} public IHttpActionResult Put(Guid id, [FromBody] ProjectDTO value) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var project = UnitOfWork.ProjectsRepository.Find(id); if (project == null) { return(NotFound()); } project.Number = value.Number; project.Name = value.Name; project.StartDate = value.StartDate; project.EndDate = value.EndDate; project.Notes = value.Notes; if (CurrentUser is SuperUser) { if (value.Organisation == null) { return(BadRequest("Organisation is required")); } project.OrganisationId = Guid.Parse(value.Organisation.Id); } try { UnitOfWork.ProjectsRepository.InsertOrUpdate(project); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
// POST api/dataLists public IHttpActionResult Post([FromBody] DataListDTO dataListDTO) { var dataList = Mapper.Map <DataList>(dataListDTO); ModelState.Clear(); Validate(dataList); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (CurrentUser is SuperUser) { dataList.OrganisationId = Guid.Parse(dataListDTO.Organisation.Id); dataList.Organisation = null; } else { dataList.OrganisationId = CurrentOrganisationId.Value; dataList.Organisation = null; } var order = 1; foreach (var item in dataList.AllItems) { item.Order = order++; } try { UnitOfWork.DataListsRepository.InsertOrUpdate(dataList); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult Approve(Guid id) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } var connectionRequest = UnitOfWork.OrgConnectionRequestsRepository.Find(id); if (connectionRequest == null) { return(NotFound()); } var organisation = UnitOfWork.OrganisationRepository.Find(connectionRequest.Organisation.Id); var orgUser = UnitOfWork.OrgUsersRepository.Find(connectionRequest.OrgUser.Id); var subscriptionService = new SubscriptionService(UnitOfWork); // update the connection request. connectionRequest.IsApproved = true; connectionRequest.ApprovalDate = DateTimeService.UtcNow; UnitOfWork.OrgConnectionRequestsRepository.InsertOrUpdate(connectionRequest); // move the user to this organization subscriptionService.MoveUserToOrganization(organisation, orgUser); // insert notification emails NotifyUserAboutApprovedRequest(organisation.Name, orgUser.Email); NotifyOrgAdminAboutApprovedRequest(organisation, orgUser); try { UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult Delete(Guid id) { if (id == Guid.Empty) { return(BadRequest("id is empty")); } if (id == CurrentUser.Id) { throw new InvalidOperationException("Current user cannot be deleted"); } var orguser = UnitOfWork.OrgUsersRepository.Find(id); if (orguser == null) { return(NotFound()); } if (orguser.IsRootUser) { return(BadRequest("root users cannot be deleted")); } try { UnitOfWork.OrgUsersRepository.Delete(id); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); return(Ok()); } catch (DbUpdateException dbEx) { return(InternalServerError(dbEx)); } catch (Exception ex) { return(InternalServerError(ex)); } }
public IHttpActionResult AddRelationship(Guid datalistId, [FromBody] AddDataListRelationshipReqDTO req) { var owner = UnitOfWork.DataListsRepository.Find(datalistId); if (owner == null || owner.OrganisationId != CurrentOrganisationId) { return(NotFound()); } var datalist = UnitOfWork.DataListsRepository.Find(req.DataListId); if (datalist == null || datalist.OrganisationId != CurrentOrganisationId) { return(BadRequest()); } var newOrder = owner.Relationships.Select(r => r.Order).DefaultIfEmpty().Max() + 1; var relationship = new DataListRelationship() { DataListId = req.DataListId, Name = req.Name, OwnerId = datalistId, Order = newOrder }; try { UnitOfWork.DataListRelationshipsRepository.InsertOrUpdate(relationship); UnitOfWork.Save(); MemoryCacher.DeleteStartingWith(CACHE_KEY); } catch (Exception ex) { return(InternalServerError(ex)); } var result = (Mapper.Map <DataListRelationshipDTO>(relationship)); return(Ok(result)); }