Example #1
0
        public async Task <ActionResponse <BusinessPartnerDto> > Update(BusinessPartnerDto entityDto)
        {
            try
            {
                List <ContactPersonDto> contacts = entityDto.BusinessPartnerContacts != null ?
                                                   new List <ContactPersonDto>(entityDto.BusinessPartnerContacts) : new List <ContactPersonDto>();

                var entityToUpdate = mapper.Map <BusinessPartnerDto, BusinessPartner>(entityDto);
                unitOfWork.GetGenericRepository <BusinessPartner>().Update(entityToUpdate);
                unitOfWork.Save();

                mapper.Map(entityToUpdate, entityDto);
                entityDto.BusinessPartnerContacts = contacts;

                if ((await ModifyBusinessPartnerContacts(entityDto))
                    .IsNotSuccess(out ActionResponse <BusinessPartnerDto> contactResponse, out entityDto))
                {
                    return(contactResponse);
                }

                if ((await GetById(entityToUpdate.Id)).IsNotSuccess(out ActionResponse <BusinessPartnerDto> response, out entityDto))
                {
                    return(response);
                }

                return(await ActionResponse <BusinessPartnerDto> .ReturnSuccess(entityDto));
            }
            catch (Exception)
            {
                return(await ActionResponse <BusinessPartnerDto> .ReturnError("Greška prilikom ažuriranja poslovnog partnera."));
            }
        }
        public int CreateBusinessPartner(BusinessPartnerDto dto, int customerId)
        {
            BusinessPartner partner = new BusinessPartner();

            UpdatePartner(dto, ref partner);

            var customer = _repository.Load <Customer>(customerId);

            using (TransactionScope scope = new TransactionScope())
            {
                int returnVal = -1;
                try
                {
                    customer.Partners.Add(partner);
                    _repository.Save <BusinessPartner>(partner);
                    _repository.Update <Customer>(customer);
                    returnVal = partner.Id;
                    scope.Complete();
                }
                catch (Exception ex)
                {
                    _log.Error("Error during creatin new Business Partner", ex);
                }
                return(returnVal);
            }
        }
 public void UpdatePartner(BusinessPartnerDto dto, ref BusinessPartner poco)
 {
     poco.Description = dto.Description;
     poco.Iban        = dto.Iban;
     poco.Id          = dto.Id;
     poco.Name        = dto.Title;
 }
        public async Task <BusinessPartnerDto> Update([FromRoute] string cid,
                                                      [FromBody] BusinessPartnerDto businessPartner, CancellationToken cancellationToken)
        {
            var result = await _service
                         .UpdateBusinessPartnerAsync(cid, _mapper.Map <BusinessPartner>(businessPartner), cancellationToken);

            return(_mapper.Map <BusinessPartnerDto>(result));
        }
        public async Task <BusinessPartnerDto> AddNew([FromBody] BusinessPartnerDto businessPartner,
                                                      CancellationToken cancellationToken)
        {
            _logger.LogDebug($"Adding new customer {businessPartner.Name}");
            var result =
                await _service.AddBusinessPartnerAsync(_mapper.Map <BusinessPartner>(businessPartner),
                                                       cancellationToken);

            return(_mapper.Map <BusinessPartnerDto>(result));
        }
        public bool UpdateBusinessPartner(BusinessPartnerDto dto, int customerId)
        {
            BusinessPartner partner = _repository.Load <BusinessPartner>(dto.Id);

            UpdatePartner(dto, ref partner);

            bool returnVal = false;

            using (TransactionScope scope = new TransactionScope())
            {
                try
                {
                    _repository.Update <BusinessPartner>(partner);
                    _repository.Flush();
                    returnVal = true;
                    scope.Complete();
                }
                catch (Exception ex)
                {
                    _log.Error("Error during updating business partner", ex);
                }
            }
            return(returnVal);
        }
Example #7
0
        public async Task <ActionResponse <BusinessPartnerDto> > ModifyBusinessPartnerContacts(BusinessPartnerDto entityDto)
        {
            try
            {
                var entity = unitOfWork.GetGenericRepository <BusinessPartner>()
                             .FindBy(e => e.Id == entityDto.Id, includeProperties: "BusinessPartnerContacts");

                var currentContacts = mapper.Map <List <ContactPerson>, List <ContactPersonDto> >(entity.BusinessPartnerContacts.ToList());

                var newContacts = entityDto.BusinessPartnerContacts
                                  .Select(c =>
                {
                    c.BusinessPartnerId = entityDto.Id;
                    return(c);
                }).ToList();

                var contactsToRemove = currentContacts.Where(cet => !newContacts
                                                             .Select(f => f.Id).Contains(cet.Id)).ToList();

                var contactsToAdd = newContacts
                                    .Where(nt => !currentContacts.Select(cd => cd.Id).Contains(nt.Id))
                                    .Select(c =>
                {
                    c.BusinessPartnerId = entityDto.Id;
                    return(c);
                }).ToList();

                var contactsToModify = newContacts.Where(cd => currentContacts
                                                         .Select(nd => nd.Id).Contains(cd.Id)).ToList();

                if ((await RemoveContacts(contactsToRemove))
                    .IsNotSuccess(out ActionResponse <List <ContactPersonDto> > removeResponse))
                {
                    return(await ActionResponse <BusinessPartnerDto> .ReturnError("Neuspješno micanje kontakata za poslovnog partnera."));
                }

                if ((await AddContacts(contactsToAdd)).IsNotSuccess(out ActionResponse <List <ContactPersonDto> > addResponse, out contactsToAdd))
                {
                    return(await ActionResponse <BusinessPartnerDto> .ReturnError("Neuspješno dodavanje kontakata za poslovnog partnera."));
                }

                if ((await ModifyContacts(contactsToModify)).IsNotSuccess(out ActionResponse <List <ContactPersonDto> > modifyResponse, out contactsToAdd))
                {
                    return(await ActionResponse <BusinessPartnerDto> .ReturnError("Neuspješno ažuriranje kontakata za poslovnog partnera."));
                }

                return(await ActionResponse <BusinessPartnerDto> .ReturnSuccess(entityDto, "Uspješno izmijenjeni dokumenti studenta."));
            }
            catch (Exception)
            {
                return(await ActionResponse <BusinessPartnerDto> .ReturnError($"Greška prilikom ažuriranja kontakata za poslovnog partnera."));
            }
        }
Example #8
0
 public BusinessPartnerViewModel(BusinessPartnerDto partner)
 {
     _partner = partner;
     IsNew    = false;
 }
Example #9
0
 public BusinessPartnerViewModel()
 {
     _partner = new BusinessPartnerDto();
     IsNew    = true;
 }
Example #10
0
 public bool UpdatePartner(BusinessPartnerDto partner, int customerId)
 {
     return(PartnerServices.UpdateBusinessPartner(partner, customerId));
 }
Example #11
0
 public int CreatePartner(BusinessPartnerDto partnerDto, int customerId)
 {
     return(PartnerServices.CreateBusinessPartner(partnerDto, customerId));
 }
Example #12
0
 public async Task <ActionResponse <BusinessPartnerDto> > Update([FromBody] BusinessPartnerDto classType)
 {
     return(await businessPartnerService.Update(classType));
 }
 public BusinessPartnerViewModel(BusinessPartnerDto partner)
 {
     _partner = partner;
     IsNew = false;
 }
 public BusinessPartnerViewModel()
 {
     _partner = new BusinessPartnerDto();
     IsNew = true;
 }
 public bool UpdateBusinessPartner(BusinessPartnerDto partner, int customerId)
 {
     Contract.Requires <BusinessPartnersServicesException>(partner != null);
     return(default(bool));
 }