private void Update(ApplicationWithHistory applicationWithHistory) { //update existing application _targetDatabase.UpdateSingle(applicationWithHistory.ApplicationWithSubVacancy.Application); //Insert new application history records foreach (var applicationHistory in applicationWithHistory.ApplicationHistory.Where(a => a.ApplicationHistoryId == 0)) { _targetDatabase.Insert(applicationHistory); } //Update existing application history records foreach (var applicationHistory in applicationWithHistory.ApplicationHistory.Where(a => a.ApplicationHistoryId != 0)) { _targetDatabase.UpdateSingle(applicationHistory); } var schoolAttended = applicationWithHistory.ApplicationWithSubVacancy.SchoolAttended; if (schoolAttended != null) { if (schoolAttended.SchoolAttendedId == 0) { //Insert school attended if not already present _targetDatabase.Insert(schoolAttended); } else { //Otherwise update _targetDatabase.UpdateSingle(schoolAttended); } } }
public DomainVacancy Update(DomainVacancy entity) { _logger.Debug("Calling database to update apprenticeship vacancy with id={0}", entity.VacancyId); _logger.Info( $"[{entity.VacancyGuid}] Calling database to update the following vacancy: {JsonConvert.SerializeObject(entity, Formatting.Indented, new JsonSerializerSettings { ContractResolver = new ExcludeLiveClosingDateResolver() })}"); UpdateEntityTimestamps(entity); // Do we need this? var dbVacancy = _mapper.Map <DomainVacancy, Vacancy>(entity); PopulateIds(entity, dbVacancy); var previousVacancyState = GetBy(entity.VacancyId); _logger.Info( $"[{entity.VacancyGuid}] Calling database to update the following vacancy: {JsonConvert.SerializeObject(dbVacancy, Formatting.Indented, new JsonSerializerSettings { ContractResolver = new ExcludeLiveClosingDateResolver() })}"); _getOpenConnection.UpdateSingle(dbVacancy); SaveTextFieldsFor(dbVacancy.VacancyId, entity); SaveAdditionalQuestionsFor(dbVacancy.VacancyId, entity); SaveCommentsFor(dbVacancy.VacancyId, entity); UpdateVacancyHistory(previousVacancyState, dbVacancy); _logger.Debug("Updated apprenticeship vacancy with to database with id={0}", entity.VacancyId); return(GetByMapped(entity.VacancyId)); }
public ApiUser Update(ApiUser apiUser) { var sql = "SELECT * FROM ExternalSystemPermission esp WHERE Username = @ExternalSystemId"; var externalSystemPermission = _getOpenConnection.Query <ExternalSystemPermission>(sql, new { apiUser.ExternalSystemId }).Single(); externalSystemPermission.UserParameters = string.Join(",", apiUser.AuthorisedApiEndpoints.Select(ae => ApiEndpointsCodeMap[ae])); _getOpenConnection.UpdateSingle(externalSystemPermission); return(GetApiUser(apiUser.ExternalSystemId)); }
public List <VacancyLocation> Update(List <VacancyLocation> locationAddresses) { foreach (var vacancyLocationAddress in locationAddresses) { var vacancyLocation = _mapper.Map <VacancyLocation, Entities.VacancyLocation>(vacancyLocationAddress); PopulateLocalAuthorityId(vacancyLocationAddress, vacancyLocation); PopulateCountyId(vacancyLocationAddress, vacancyLocation); _getOpenConnection.UpdateSingle(vacancyLocation); } return(locationAddresses); }
public ProviderSite Update(ProviderSite providerSite) { _logger.Debug("Saving provider site with ProviderSiteId={0}", providerSite.ProviderSiteId); var dbProviderSite = MapProviderSite(providerSite); if (!_getOpenConnection.UpdateSingle(dbProviderSite)) { throw new Exception($"Failed to save provider site with ProviderSiteId={providerSite.ProviderSiteId}"); } foreach (var providerSiteRelationship in providerSite.ProviderSiteRelationships) { var dbProviderSiteRelationship = _mapper.Map <ProviderSiteRelationship, Entities.ProviderSiteRelationship>(providerSiteRelationship); if (!_getOpenConnection.UpdateSingle(dbProviderSiteRelationship)) { throw new Exception($"Failed to save provider site relationship with ProviderSiteRelationshipId={providerSiteRelationship.ProviderSiteRelationshipId}"); } } return(GetById(providerSite.ProviderSiteId)); }
public ProviderUser Update(ProviderUser providerUser) { _logger.Debug("Updating provider user with ProviderUserId={0}", providerUser.ProviderUserId); UpdateEntityTimestamps(providerUser); var dbProviderUser = MapProviderUser(providerUser); _getOpenConnection.UpdateSingle(dbProviderUser); _logger.Debug("Updated provider user with ProviderUserId={0}", providerUser.ProviderUserId); return(MapProviderUser(dbProviderUser)); }
private void Update(CandidateWithHistory candidateWithHistory) { //update existing person _targetDatabase.UpdateSingle(candidateWithHistory.CandidatePerson.Person); //update existing candidate _targetDatabase.UpdateSingle(candidateWithHistory.CandidatePerson.Candidate); //Insert new candidate history records foreach (var candidateHistory in candidateWithHistory.CandidateHistory.Where(a => a.CandidateHistoryId == 0)) { _targetDatabase.Insert(candidateHistory); } var schoolAttended = candidateWithHistory.CandidatePerson.SchoolAttended; if (schoolAttended != null) { if (schoolAttended.SchoolAttendedId == 0) { //Insert school attended if not already present _targetDatabase.Insert(schoolAttended); } else { //Otherwise update _targetDatabase.UpdateSingle(schoolAttended); } } //Update existing candidate history records foreach (var candidateHistory in candidateWithHistory.CandidateHistory.Where(a => a.CandidateHistoryId != 0)) { _targetDatabase.UpdateSingle(candidateHistory); } }
/// <summary> /// UpdateEntityTimeStamps /// Save to Collection /// Return Saved object - this should be returned from the collection.save operation. /// </summary> /// <param name="provider"></param> /// <returns></returns> public Provider Update(Provider provider) { _logger.Debug("Saving provider with Ukprn={0}", provider.Ukprn); var dbProvider = MapProvider(provider); // TODO: SQL: AG: note that we are not attempting to insert a new Provider, we always update (temporary). if (!_getOpenConnection.UpdateSingle(dbProvider)) { throw new Exception($"Failed to save provider with Ukprn={provider.Ukprn}"); } return(MapProvider(dbProvider)); }
public DomainEmployer Save(DomainEmployer employer) { var dbEmployer = _mapper.Map <DomainEmployer, Employer>(employer); PopulateCountyId(employer, dbEmployer); if (dbEmployer.EmployerId == 0) { dbEmployer.EmployerStatusTypeId = 1; dbEmployer.EmployerId = (int)_getOpenConnection.Insert(dbEmployer); } else { const string sql = "SELECT * FROM dbo.Employer WHERE EmployerId = @EmployerId"; var sqlParams = new { dbEmployer.EmployerId }; var existingEmployer = _getOpenConnection.Query <Employer>(sql, sqlParams).Single(); dbEmployer.CountyId = existingEmployer.CountyId; dbEmployer.LocalAuthorityId = existingEmployer.LocalAuthorityId; dbEmployer.GeocodeEasting = existingEmployer.GeocodeEasting; dbEmployer.GeocodeNorthing = existingEmployer.GeocodeNorthing; dbEmployer.PrimaryContact = existingEmployer.PrimaryContact; dbEmployer.NumberofEmployeesAtSite = existingEmployer.NumberofEmployeesAtSite; dbEmployer.NumberOfEmployeesInGroup = existingEmployer.NumberOfEmployeesInGroup; dbEmployer.OwnerOrgnistaion = existingEmployer.OwnerOrgnistaion; dbEmployer.CompanyRegistrationNumber = existingEmployer.CompanyRegistrationNumber; dbEmployer.TotalVacanciesPosted = existingEmployer.TotalVacanciesPosted; dbEmployer.BeingSupportedBy = existingEmployer.BeingSupportedBy; dbEmployer.LockedForSupportUntil = existingEmployer.LockedForSupportUntil; dbEmployer.DisableAllowed = existingEmployer.DisableAllowed; dbEmployer.TrackingAllowed = existingEmployer.TrackingAllowed; _getOpenConnection.UpdateSingle(dbEmployer); } return(GetById(dbEmployer.EmployerId)); }
public AgencyUser Save(AgencyUser entity) { _logger.Debug("Called SQL DB to save AgencyUser with AgencyUserId={0}", entity.AgencyUserId); UpdateEntityTimestamps(entity); var dbEntity = _mapper.Map <AgencyUser, Entities.AgencyUser>(entity); if (dbEntity.AgencyUserGuid == Guid.Empty) { dbEntity.AgencyUserGuid = Guid.NewGuid(); } // TODO: SQL: AG: consider generalising (and testing) SqlException handling below. try { var result = (int)_getOpenConnection.Insert(dbEntity); dbEntity.AgencyUserId = result; } catch (SqlException e) when(e.Number == 2601) { if (!_getOpenConnection.UpdateSingle(dbEntity)) { throw new Exception("Failed to update record after failed insert", e); } } _logger.Debug("Saved AgencyUser with AgencyUserId={0}", entity.AgencyUserId); var endResult = _mapper.Map <Entities.AgencyUser, AgencyUser>(dbEntity); endResult.Role = entity.Role; endResult.RegionalTeam = entity.RegionalTeam; return(endResult); }
public VacancyOwnerRelationship Save(VacancyOwnerRelationship vacancyOwnerRelationship) { var dbVacancyOwnerRelationship = _mapper.Map <VacancyOwnerRelationship, Entities.VacancyOwnerRelationship>(vacancyOwnerRelationship); dbVacancyOwnerRelationship.StatusTypeId = (int)VacancyOwnerRelationshipStatusTypes.Live; dbVacancyOwnerRelationship.EditedInRaa = true; if (dbVacancyOwnerRelationship.VacancyOwnerRelationshipId == 0) { dbVacancyOwnerRelationship.VacancyOwnerRelationshipId = (int)_getOpenConnection.Insert(dbVacancyOwnerRelationship); } else { const string sql = @" SELECT * FROM dbo.VacancyOwnerRelationship WHERE VacancyOwnerRelationshipId = @VacancyOwnerRelationshipId AND StatusTypeId = @StatusTypeId"; var sqlParams = new { dbVacancyOwnerRelationship.VacancyOwnerRelationshipId, dbVacancyOwnerRelationship.StatusTypeId }; var existingVacancyOwnerRelationship = _getOpenConnection.Query <Entities.VacancyOwnerRelationship>(sql, sqlParams).Single(); dbVacancyOwnerRelationship.ContractHolderIsEmployer = existingVacancyOwnerRelationship.ContractHolderIsEmployer; dbVacancyOwnerRelationship.ManagerIsEmployer = existingVacancyOwnerRelationship.ManagerIsEmployer; dbVacancyOwnerRelationship.Notes = existingVacancyOwnerRelationship.Notes; dbVacancyOwnerRelationship.EmployerLogoAttachmentId = existingVacancyOwnerRelationship.EmployerLogoAttachmentId; dbVacancyOwnerRelationship.NationWideAllowed = existingVacancyOwnerRelationship.NationWideAllowed; _getOpenConnection.UpdateSingle(dbVacancyOwnerRelationship); } return(GetByIds(new[] { dbVacancyOwnerRelationship.VacancyOwnerRelationshipId }).Single()); }
public ApprenticeshipVacancy Save(ApprenticeshipVacancy entity) { _logger.Debug("Calling database to save apprenticeship vacancy with id={0}", entity.EntityId); UpdateEntityTimestamps(entity); // TODO: Map from ApprenticeshipVacancy to Apprenticeship ?? var dbVacancy = _mapper.Map <ApprenticeshipVacancy, Vacancy.Vacancy>(entity); dbVacancy.VacancyLocationTypeCode = "S"; // TODO: Can't get this right unless / until added to ApprenticeshipVacancy or exclude from updates // TODO: This should be the other way around (to avoid a race condition) // and be in a single call to the database (to avoid a double latency hit) // This should be done as a single method in _getOpenConnection try { _getOpenConnection.Insert(dbVacancy); } catch (Exception ex) { // TODO: Detect key violation if (!_getOpenConnection.UpdateSingle(dbVacancy)) { throw new Exception("Failed to update record after failed insert", ex); } if (entity.LocationAddresses != null) { _getOpenConnection.MutatingQuery <int>(@" -- TODO: Could be optimised. Locking may possibly be an issue -- TODO: Should possibly split address into separate repo method DELETE Address.PostalAddress WHERE PostalAddressId IN ( SELECT PostalAddressId FROM Vacancy.VacancyLocation WHERE VacancyId = @VacancyId ) DELETE Vacancy.VacancyLocation FROM Vacancy.VacancyLocation WHERE VacancyId = @VacancyId "); } } if (entity.LocationAddresses != null) // TODO: Split into separate repository method { // TODO: Optimisation - insert several in one SQL round-trip foreach (var location in entity.LocationAddresses) { var dbLocation = new Vacancy.VacancyLocation() { VacancyId = dbVacancy.VacancyId, DirectApplicationUrl = "TODO", NumberOfPositions = location.NumberOfPositions }; var dbAddress = _mapper.Map <Domain.Entities.Locations.Address, Address.PostalAddress>(location.Address); dbLocation.PostalAddressId = (int)_getOpenConnection.Insert(dbAddress); _getOpenConnection.Insert(dbLocation); } } _logger.Debug("Saved apprenticeship vacancy with to database with id={0}", entity.EntityId); // TODO: Mongo used to map dbVacancy back to entity, not sure what the point in that is. return(entity); }