Exemple #1
0
        /// <summary>
        /// Delete the With Attach Entiy.
        /// </summary>
        /// <param name="Entiy">The Entiy.</param>
        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
        public bool DeleteWithAttachEntiy(ContactDto t)
        {
            var dbEntity = typeAdapter.ConvertDtoToEntities(t);

            entiesrepository.Attach(dbEntity);
            entiesrepository.Delete(dbEntity);
            entiesrepository.Save();
            return(true);
        }
Exemple #2
0
        public ActionResult DeleteConfirmed(int id)
        {
            Contact contact = repo.SingleOrDefault(id);

            repo.Delete(contact);
            return(RedirectToAction("Index"));
        }
       public void Delete(Contact model)
       {
           if (!User.Identity.IsAuthenticated)
           {
               Response.End();
           }

           var id = model.ContactId;
           var contact = contactrepo.GetContactById(id);

           try
           {
               contactrepo.Delete(contact);
               contactrepo.Save();//persist change

               //make sure that client side knows we don't have errors
               var newmodel = helper.ToDictModel(contact);
               newmodel.Add("isError", false);
               Response.Write(serializer.Serialize(newmodel));
               Response.End();
           }
           catch (Exception ex)
           {
               var dictmodel = helper.ToDictModel(contact);
               dictmodel.Add("isError", ex.Message);
               Response.Write(serializer.Serialize(dictmodel));
               Response.End();
           }
          
       }
Exemple #4
0
        public void TearDown()
        {
            var repository = new ContactRepository();
            var contacts   = repository.LoadAll();

            contacts.ForEach(x => repository.Delete(x.Id));
        }
Exemple #5
0
        public async Task Arrange()
        {
            MappingBootstrapper.Initialize();

            var userNameToFind = "NotFoundUser";

            var contacts = new List <Contact>
            {
                Builder <Contact> .CreateNew()
                .With(q => q.Username = userNameToFind)
                .Build()
            }.AsQueryable();

            var mockSet       = contacts.CreateMockSet(contacts);
            var mockDbContext = CreateMockDbContext(mockSet);

            var contactRepository = new ContactRepository(mockDbContext.Object, new Mock <IUnitOfWork>().Object);

            try
            {
                await contactRepository.Delete("testuser");
            }
            catch (Exception exception)
            {
                _exception = exception;
            }
        }
Exemple #6
0
        public ActionResult DeleteConfirmed(int id)
        {
            Contact contact = ContactRepository.GetSingle(id);

            try
            {
                ContactRepository.Delete(contact);
                ContactRepository.Save();

                if (IsSuperAdmin)
                {
                    return(RedirectToAction("Index", new { storeId = contact.StoreId }));
                }
                else
                {
                    return(RedirectToAction("Index"));
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex, "Unable to delete:" + ex.StackTrace, contact);
                //Log the error (uncomment dex variable name and add a line here to write a log.
                ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
            }
            return(View(contact));
        }
Exemple #7
0
        public ActionResult DeleteOption(int id)
        {
            ContactRepository Repo = new ContactRepository();

            Repo.Delete(id);
            return(Ok());
        }
Exemple #8
0
        public ActionResult Delete(int id, ContactViewModel contactViewModel)
        {
            Contact contactToBase = _contactRepository.FindById(id);

            _contactRepository.Delete(contactToBase);

            return(RedirectToAction("Index"));
        }
Exemple #9
0
        public void DeleteContactService(ContactDTO entity)
        {
            var contact = contactRepository.GetAll().Where(r => r.ContactId == entity.ContactId).FirstOrDefault();

            contact.ContactMessage = entity.ContactMessage;
            contact.Sender         = entity.Sender;
            contact.SendingDate    = entity.SendingDate;
            contact.IsRead         = entity.IsRead;
            contactRepository.Delete(contact);
        }
        public void DeleteContact(Contact contact)
        {
            if (CurrentContacts.Contains(contact))
            {
                CurrentContacts.Remove(contact);
            }

            _contactRepository.Delete(contact);
            StatusText = string.Format("Contact ‘{0}’ was deleted.", contact.LookupName);
        }
        public void DeleteContact(Contact contact)
        {
            if (CurrentContacts.Contains(contact))
            {
                CurrentContacts.Remove(contact);
            }

            _contactRepository.Delete(contact);
            StatusText = $"Contact '{contact.LookupName}' was deleted.";
        }
        public void ICanDelete_Exposes_Delete_Entity()
        {
            var repo    = new ContactRepository(new ConcurrentDictionary <int, Contact>());
            var contact = new Contact {
                Name = "Test User"
            };

            repo.Add(contact);
            repo.Delete(contact);
        }
Exemple #13
0
        public void ICanDelete_Exposes_Delete_By_Id()
        {
            var repo    = new ContactRepository();
            var contact = new Contact {
                Name = "Test User"
            };

            repo.Add(contact);
            repo.Delete(1);
        }
        public IHttpActionResult Delete(int id)
        {
            var user = ContactRepo.Get(id);

            if (user == null)
            {
                return(StatusCode(HttpStatusCode.NoContent));
            }
            ContactRepo.Delete(id);
            return(StatusCode(HttpStatusCode.NoContent));
        }
        public void Delete_When_Called_Then_Call_Delete_AsExpected()
        {
            //Arrange
            _mockDatabase.Setup(x => x.Delete(It.IsAny <string>(), It.IsAny <SqlParameter[]>())).Verifiable();

            //Act
            _sut.Delete(1);

            //Assert
            _mockDatabase.Verify(x => x.Delete(It.IsAny <string>(), It.IsAny <SqlParameter[]>()), Times.Once);
        }
Exemple #16
0
        public void Delete_Void_ReturnNull()
        {
            _contact.Id = _contactRepository.Create(_contact);
            var result = _contactRepository.Get(_contact.Id);

            AreEqualContacts(result, _contact);

            _contactRepository.Delete(_contact.Id);
            result = _contactRepository.Get(_contact.Id);
            Assert.IsNull(result);
        }
Exemple #17
0
        // DELETE api/values/5
        public HttpResponseMessage Delete(int id)
        {
            var contact = _contactsRepository.Get().SingleOrDefault(y => y.Id == id);

            if (contact != null)
            {
                _contactsRepository.Delete(id);
                return(Request.CreateResponse(HttpStatusCode.Accepted));
            }
            return(Request.CreateResponse(HttpStatusCode.NotFound));
        }
        public async Task <ActionResult <ContactRepresentation> > Delete(Guid id)
        {
            await CheckUserIdPermission(id);

            var entity = await _repository.Delete(id);

            if (entity == null)
            {
                return(NotFound());
            }
            return(_mapper.Map <ContactRepresentation>(entity));
        }
Exemple #19
0
        public void Given_ContactRepository_DeleteContact()
        {
            int           deleteId = 1;
            ContactEntity entity   = objRepo.GetById(deleteId);

            objRepo.Delete(entity);
            databaseContext.SaveChanges();

            var result = objRepo.GetById(deleteId);

            Assert.AreEqual(result.IsActive, false);
        }
Exemple #20
0
        public void ICanDelete_Exposes_Delete_Multiple_Entities()
        {
            var repo    = new ContactRepository();
            var contact = new Contact {
                Name = "Test User"
            };

            repo.Add(contact);
            repo.Add(contact);
            repo.Delete(new List <Contact> {
                contact, contact
            });
        }
Exemple #21
0
        public void Delete_flags_correct_contact_as_inactive()
        {
            ContactRepository testContainer = GenerateSmallList();

            testContainer.Delete(12);
            var contact  = testContainer.Get(12);
            var contact2 = testContainer.Get(100);
            var contact3 = testContainer.Get(1);

            Assert.False(contact.isActiveRecord);
            Assert.True(contact2.isActiveRecord);
            Assert.True(contact3.isActiveRecord);
        }
Exemple #22
0
        public void Delete(int contactId)
        {
            using (IUnitOfWork unitOfWork = context.CreateUnitOfWork())
            {
                Contact contact = contactRepo.GetById(contactId);

                if (!contactRepo.Delete(contact))
                {
                    throw new FailedOperationException("Failed to delete Contact.", contact);
                }

                unitOfWork.SaveChanges();
            }
        }
        public IHttpActionResult Delete(long id)
        {
            try
            {
                var repository = new ContactRepository();
                repository.Delete(id);

                return(Content(HttpStatusCode.NoContent, string.Empty));
            }
            catch (Exception ex)
            {
                return(this.BadRequest(ex.Message));
            }
        }
        public void _05_Delete_should_remove_entity()
        {
            var repository = new ContactRepository();

            repository.Delete(id);

            // create a new repository for verification purposes
            var repository2 = new ContactRepository();

            var deletedEntity = repository2.Find(id);

            // assert
            deletedEntity.Should().BeNull();
        }
        public IActionResult Delete(int personId)
        {
            if (personId < 1)
            {
                return(BadRequest("Invalid ID supplied"));
            }
            try {
                repository.Delete(personId);
            }
            catch (ArgumentException) {
                return(NotFound("Person not found"));
            }

            return(NoContent());
        }
Exemple #26
0
        public ActionResult Delete(Contact contact)
        {
            try
            {
                _contact.Delete(contact);

                ViewBag.Message = "Contact deleted successfuly";
            }
            catch (Exception ex)
            {
                Common.LogError(ModuleType.Delete, ex);
            }

            return(RedirectToAction("Index"));
        }
        public ActionResult Delete(int id)
        {
            Contact contact = contactRepository.GetByID(id);

            if (contact == null)
            {
                HttpNotFound();
            }
            else
            {
                contactRepository.Delete(contact);

                return(RedirectToAction("ListContact", "Contact"));
            }
            return(View());
        }
        public void DeleteContact(Contact contact)
        {
            if (CurrentContacts.Contains(contact))
            {
                CurrentContacts.Remove(contact);
            }

            _contactRepository.Delete(contact);

            string statusMessage = string.Format(
                "Contact <{0}> was deleted.",
                contact.LookupName
                );

            UpdateStatusText(statusMessage);
        }
Exemple #29
0
        public void Delete(int id, Distributor distributor)
        {
            try
            {
                var contactToDelete = _contactRepository.GetById(id);

                if (contactToDelete.DistributorId != distributor.Id)
                {
                    throw new Exception(string.Format("The contact with Id: {0} does not belong to this user.", distributor.Id));
                }

                _contactRepository.Delete(contactToDelete);
            }
            catch (Exception exception)
            {
                throw new Exception(exception.Message);
            }
        }
        public ActionResult DeleteConfirmed(int?id)
        {
            if (id != null)
            {
                ContactRepository contactRepo = new ContactRepository();

                Contact contact = contactRepo.GetById(id.Value);

                if (contact != null && contact.UserID == AuthenticationService.LoggedUser.Id)
                {
                    contact.Groups.Clear(); //one row took us like an hour to find!!!
                    contactRepo.Delete(contact);

                    return(RedirectToAction("Index"));
                }
            }

            return(HttpNotFound());
        }
        public void DeleteOnContactRepository()
        {
            //Arrange
            ContactNumberRepository contactNumberRepository = new ContactNumberRepository(_config);
            ContactRepository contactRepository = new ContactRepository(_config, contactNumberRepository);

            var contactToDelete = _contacts[4];

            //Act
            contactRepository.Delete(contactToDelete.Id);

            Contact contact = contactRepository.Get(contactToDelete.Id);

            //Assert
            Assert.IsNull(contact);

            //Assert all contact Numbers for this contact have also been removed
            var contactNumbers = contactNumberRepository.GetAll().Where(cn => cn.ContactId == contactToDelete.Id).ToList();

            Assert.AreEqual(0, contactNumbers.Count);
        }
Exemple #32
0
        public override bool OnContextItemSelected(IMenuItem item)
        {
            if (_position < 0) return false;

            switch (item.ItemId)
            {
                case Resource.Id.editSMS:
                    using (var editSmsIntent = new Intent())
                    {
                        editSmsIntent.PutExtra ("groupId", _smsGroups[_position].Id);
                        editSmsIntent.SetClass (Activity, typeof(EditSmsGroupActivity));
                        StartActivity (editSmsIntent);
                    }
                    break;
                case Resource.Id.sendSMS:
                    using (var sendMessage = new Intent())
                    {
                        sendMessage.PutExtra ("groupId", _smsGroups[_position].Id);
                        sendMessage.SetClass (Activity, typeof(SendMessageActivity));
                        StartActivity (sendMessage);
                    }
                    break;
                case Resource.Id.deleteSMS:
                    new AlertDialog.Builder(Activity)
                        .SetTitle ("Delete SMS Group")
                        .SetMessage (string.Format ("Are you sure you want to delete the following group: {0}",
                                                    _smsGroups[_position]))
                        .SetPositiveButton ("Ok", (o, e) => {
                            _progressDialog = new ProgressDialog(Activity);
                            _progressDialog.SetTitle ("Delete SMS Group");
                            _progressDialog.SetMessage ("Please wait.  Deleting SMS Group...");
                            _progressDialog.Show ();

                            Task.Factory
                                .StartNew(() => {
                                    var smsGroup = _smsGroups[_position];

                                    //Delete all messages, group memebers, and then delete sms group
                                    var messageRepo = new SmsMessageRepository();
                                    var messages = messageRepo.GetAllForGroup (smsGroup.Id);
                                    messages.ForEach (messageRepo.Delete);

                                    _contactRepo = new ContactRepository(Activity);
                                    var contacts = _contactRepo.GetMembersForSmsGroup(smsGroup.Id);
                                    contacts.ForEach (c => _contactRepo.Delete (c));

                                    _smsGroupRepo.Delete (smsGroup);
                                })
                                .ContinueWith(task =>
                                    Activity.RunOnUiThread(() => {
                                        _smsGroups.RemoveAt (_position);
                                        ListAdapter = new GroupListAdapter(Activity, _smsGroups);
                                        ((BaseAdapter)ListAdapter).NotifyDataSetChanged ();
                                        _progressDialog.Dismiss ();
                                    }));
                        })
                        .SetNegativeButton ("Cancel", (o, e) => { })
                        .Show ();
                    break;
            }

            return base.OnContextItemSelected (item);
        }