public IHttpActionResult DeactivateAdditionalContact(int deactivateId, int replacementId)
        {
            if (deactivateId <= 0 || replacementId <= 0)
            {
                return(BadRequest());
            }

            var additionalContactToDeactivate = _unitOfWork.AdditionalContacts.FindSingle(ac => ac.Id == deactivateId);
            var replacementAdditionalContact  = _unitOfWork.AdditionalContacts.FindSingle(ac => ac.Id == replacementId);

            if (additionalContactToDeactivate == null)
            {
                return(BadRequest());
            }

            try
            {
                additionalContactToDeactivate.Active = false;

                _unitOfWork.Complete();

                _logger.SuccessfulUpdateServerLog(HttpContext.Current.User, DtoHelper.CreateAdditionalContactDto(replacementAdditionalContact),
                                                  DtoHelper.CreateAdditionalContactDto(replacementAdditionalContact));

                return(Ok());
            }
            catch (Exception ex)
            {
                _logger.FailedUpdateServerLog(HttpContext.Current.User, ex.Message, ex.InnerException, $"Attempt to deactivate Additional Contact Id: {deactivateId}", $"Supplied replacement Additional Contact Id: {replacementId}");

                return(InternalServerError(ex));
            }
        }
        public HttpStatusCode DeactivateAdditionalContact(int deactivateId, int?replacementId)
        {
            var additionalContactToDeactivate = _db.AdditionalContacts.SingleOrDefault(pc => pc.Id == deactivateId);
            var replacementAdditionalContact  = _db.AdditionalContacts.SingleOrDefault(pc => pc.Id == replacementId);

            if (Equals(additionalContactToDeactivate, null))
            {
                return(HttpStatusCode.BadRequest);
            }

            try
            {
                additionalContactToDeactivate.Active = false;

                _db.SaveChanges();

                _mongoMongoLogger.SuccessfulUpdateServerLog(HttpContext.Current.User, DtoHelper.CreateAdditionalContactDto(replacementAdditionalContact),
                                                            DtoHelper.CreateAdditionalContactDto(replacementAdditionalContact));

                return(HttpStatusCode.OK);
            }
            catch (Exception ex)
            {
                _mongoMongoLogger.FailedUpdateServerLog(HttpContext.Current.User, ex.Message, ex.InnerException, $"Attempt to deactivate Additional Contact Id: {deactivateId}", $"Supplied replacement Additional Contact Id: {replacementId}");

                return(HttpStatusCode.InternalServerError);
            }
        }
        public IHttpActionResult AddNewAdditionalContact([FromBody] AdditionalContact newAdditionalContact)
        {
            if (Equals(newAdditionalContact, null))
            {
                return(BadRequest());
            }

            var additionalContact = _unitOfWork.AdditionalContacts.Find(ac => ac.Email == newAdditionalContact.Email);

            if (additionalContact.Any())
            {
                return(Content(HttpStatusCode.Conflict, "Contact with same email already exists."));
            }

            try
            {
                _unitOfWork.AdditionalContacts.Add(newAdditionalContact);
                _unitOfWork.Complete();

                _logger.SuccessfullyAddedServerLog(HttpContext.Current.User, DtoHelper.CreateAdditionalContactDto(newAdditionalContact));

                return(Ok(DtoHelper.CreateAdditionalContactDto(newAdditionalContact)));
            }
            catch (Exception ex)
            {
                _logger.FailedToCreateServerLog(HttpContext.Current.User, ex.Message, ex.InnerException, DtoHelper.CreateAdditionalContactDto(newAdditionalContact));

                return(InternalServerError(ex));
            }
        }
        public IHttpActionResult UpdateAdditionalContact(AdditionalContact additionalContact)
        {
            if (Equals(additionalContact, null))
            {
                return(BadRequest());
            }

            var additionalContactToUpdate =
                _unitOfWork.AdditionalContacts.FindSingle(ac => ac.Id == additionalContact.Id);

            if (additionalContactToUpdate == null)
            {
                return(BadRequest());
            }

            var additionalContactBeforeUpdate = DtoHelper.CreateAdditionalContactDto(additionalContact);

            try
            {
                if (ConcurrencyChecker.canSaveChanges(additionalContact.Version, additionalContactToUpdate.Version))
                {
                    additionalContactToUpdate.Name                   = additionalContact.Name;
                    additionalContactToUpdate.Email                  = additionalContact.Email;
                    additionalContactToUpdate.Telephone              = additionalContact.Telephone;
                    additionalContactToUpdate.System                 = additionalContact.System;
                    additionalContactToUpdate.Fax                    = additionalContact.Fax;
                    additionalContactToUpdate.Salutation             = additionalContact.Salutation;
                    additionalContactToUpdate.Version                = additionalContact.Version + 1;
                    additionalContactToUpdate.Role                   = additionalContact.Role;
                    additionalContactToUpdate.NotificationSubscriber = additionalContact.NotificationSubscriber;
                    additionalContactToUpdate.Active                 = additionalContact.Active;

                    _unitOfWork.Complete();

                    _logger.SuccessfulUpdateServerLog(HttpContext.Current.User, DtoHelper.CreateAdditionalContactDto(additionalContact), DtoHelper.CreateAdditionalContactDto(additionalContactToUpdate));

                    return(Ok(DtoHelper.CreateAdditionalContactDto(additionalContactToUpdate)));
                }
                else
                {
                    _logger.ConcurrenyServerLog <object, object>(HttpContext.Current.User, additionalContact);

                    return(Conflict());
                }
            }
            catch (Exception ex)
            {
                _logger.FailedUpdateServerLog <Exception, object, object>(HttpContext.Current.User, ex.Message, ex.InnerException, DtoHelper.CreateAdditionalContactDto(additionalContact));

                return(InternalServerError());
            }
        }
        public IHttpActionResult GetAdditionalContactsById(int id)
        {
            if (id <= 0)
            {
                return(BadRequest());
            }

            var additionalContact = _unitOfWork.AdditionalContacts.FindSingle(ac => ac.Id == id);

            if (Equals(additionalContact, null))
            {
                return(BadRequest());
            }

            return(Ok(DtoHelper.CreateAdditionalContactDto(additionalContact)));
        }
        public HttpStatusCode UpdateAdditionalContact(AdditionalContact additionalContact)
        {
            var systemManagerToUpdate     = _db.AdditionalContacts.SingleOrDefault(sm => sm.Id == additionalContact.Id);
            var systemManagerBeforeUpdate = DtoHelper.CreateAdditionalContactDto(systemManagerToUpdate);

            if (Equals(systemManagerToUpdate, null))
            {
                return(HttpStatusCode.BadRequest);
            }

            try
            {
                if (ConcurrencyChecker.canSaveChanges(additionalContact.Version, systemManagerToUpdate.Version))
                {
                    systemManagerToUpdate.Name                   = additionalContact.Name;
                    systemManagerToUpdate.Email                  = additionalContact.Email;
                    systemManagerToUpdate.Telephone              = additionalContact.Telephone;
                    systemManagerToUpdate.System                 = additionalContact.System;
                    systemManagerToUpdate.Fax                    = additionalContact.Fax;
                    systemManagerToUpdate.Salutation             = additionalContact.Salutation;
                    systemManagerToUpdate.Version                = additionalContact.Version + 1;
                    systemManagerToUpdate.Role                   = additionalContact.Role;
                    systemManagerToUpdate.NotificationSubscriber = additionalContact.NotificationSubscriber;
                    systemManagerToUpdate.Active                 = additionalContact.Active;

                    _db.SaveChanges();

                    _mongoMongoLogger.SuccessfulUpdateServerLog(HttpContext.Current.User, systemManagerBeforeUpdate, DtoHelper.CreateAdditionalContactDto(systemManagerToUpdate));

                    return(HttpStatusCode.OK);
                }
                else
                {
                    _mongoMongoLogger.ConcurrenyServerLog <object, object>(HttpContext.Current.User, additionalContact);

                    return(HttpStatusCode.Conflict);
                }
            }
            catch (Exception ex)
            {
                _mongoMongoLogger.FailedUpdateServerLog <Exception, object, object>(HttpContext.Current.User, ex.Message, ex.InnerException, additionalContact);

                return(HttpStatusCode.InternalServerError);
            }
        }
        public AdditionalContactDto GetAdditionalContactByEmail(string email)
        {
            var additionalContact = _db.AdditionalContacts.SingleOrDefault(sm => sm.Email == email);

            return(DtoHelper.CreateAdditionalContactDto(additionalContact));
        }
        public AdditionalContactDto GetAdditionalContactById(int id)
        {
            var additionalContact = _db.AdditionalContacts.SingleOrDefault(sm => sm.Id == id);

            return(DtoHelper.CreateAdditionalContactDto(additionalContact));
        }