// 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));
}
