public async Task <SubscriberDTO> Edit(SubscriberDTO dto)
{
var subscriber = this._mapper.Map <Subscriber>(dto);
var result = await this._subscriberRepository.Edit(subscriber);
return(this._mapper.Map <SubscriberDTO>(result));
}
public async Task <ActionResult <bool> > RegisterAsync([FromBody] SubscriberDTO subscriber)
{
SubscriberModel subscriberModel = _mapper.Map <SubscriberModel>(subscriber);
var response = await _subscriberService.RegisterAsync(subscriberModel);
if (response)
{
return(Ok(response));
}
return(BadRequest(false));
}
public async Task <IActionResult> Add([FromBody] SubscriberDTO subscriber)
{
var outputHandler = await _service.Add(subscriber);
if (outputHandler.IsErrorOccured)
{
return(BadRequest(outputHandler.Message));
}
return(Created("", outputHandler.Message));
}
public async Task <ActionResult <bool> > post(SubscriberDTO subscriberDTO)
{
try
{
var subsciber = _mapper.Map <SubscriberModel>(subscriberDTO);
return(await _subscriberSevice.addAsynce(subsciber, subscriberDTO.height));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> AddSubscriber([FromBody] SubscriberDTO subscriberDTO)
{
var subscriberToCreate = _mapper.Map <Subscriber>(subscriberDTO);
if (await _repository.EntityExists(subscriberToCreate))
{
return(BadRequest("You have already been added to our subscription list, thank you"));
}
_repository.Add(subscriberToCreate);
await _repository.SaveAllChanges();
return(Ok());
}
public async Task <IActionResult> Subscribe([FromBody] SubscriberDTO subscriberDTO)
{
var subscriberToAdd = _mapper.Map <Subscriber>(subscriberDTO);
if (subscriberToAdd == null)
{
return(BadRequest("Subscriber cannot be null"));
}
if (await _repository.EntityExists(subscriberToAdd))
{
return(BadRequest("Subscriber has already been added"));
}
subscriberToAdd.DateCreated = DateTime.Now;
_repository.Add(subscriberToAdd);
await _repository.SaveAllChanges();
return(Ok());
}
private SubscriberOperationDTO GetOperation(MpBulkEmailPublication publication, MpBulkEmailSubscriber subscriber)
{
var mailChimpSubscriber = new SubscriberDTO();
mailChimpSubscriber.Subscribed = subscriber.Subscribed;
mailChimpSubscriber.EmailAddress = subscriber.ThirdPartyContactId;
mailChimpSubscriber.MergeFields = subscriber.MergeFields;
var hashedEmail = CalculateMD5Hash(mailChimpSubscriber.EmailAddress.ToLower());
var operation = new SubscriberOperationDTO();
operation.Method = "PUT";
operation.Path = string.Format("lists/{0}/members/{1}", publication.ThirdPartyPublicationId, hashedEmail);
// TODO: Do we need to store this somewhere to verify subscriber processed successfully
operation.OperationId = Guid.NewGuid().ToString();
operation.Body = JsonConvert.SerializeObject(mailChimpSubscriber);
return(operation);
}
public async Task <ActionResult <bool> > Register(SubscriberDTO userRegister)
{
UserModel userToRegister = _mapper.Map <UserModel>(userRegister);
UserFileModel userFileToRegister = _mapper.Map <UserFileModel>(userRegister);
UserModel newUser = await _userService.RegisterAsync(userToRegister, userFileToRegister);
if (newUser == null)
{
Log.Information("User with email {@email} requested to create but already exists", userRegister.Email);
throw new Exception("Bad Request: Patient with email ${ userRegister.Email } requested to create but already exists");
// throw new HttpResponseException(HttpStatusCode.NotFound);
// return BadRequest($"patient with id:{newPatient.PatientId} already exists");
}
else
{
Log.Information("User with email {@email} created successfully", newUser.Email);
return(StatusCode((int)HttpStatusCode.Created));
}
}
public async Task <OutputResponse> Update(SubscriberDTO subscriber)
{
var subscriberToUpdate = await _context.Subscribers.FirstOrDefaultAsync(x => x.SubscriberId.Equals(subscriber.SubscriberId));
if (subscriberToUpdate == null)
{
return(new OutputResponse
{
IsErrorOccured = true,
Message = "Subscriber specified does not exist, update cancelled"
});
}
var isFound = await _context.Subscribers.Where(x => x.SubscriberId != subscriber.SubscriberId).AnyAsync(x => x.PhoneNumber == subscriber.PhoneNumber);
if (isFound)
{
return(new OutputResponse
{
IsErrorOccured = true,
Message = "Subscriber phone number already exist, duplicates not allowed"
});
}
//update details
subscriberToUpdate.RecipientAddress = subscriber.RecipientAddress;
subscriberToUpdate.PhoneNumber = subscriber.PhoneNumber;
subscriberToUpdate.ChannelId = subscriber.ChannelId;
await _context.SaveChangesAsync();
return(new OutputResponse
{
IsErrorOccured = false,
Message = MessageHelper.UpdateSuccess
});
}
public async Task <OutputResponse> Add(SubscriberDTO subscriber)
{
/*var isFound = await _context.Subscribers.AnyAsync(x => x.PhoneNumber.ToLower() == subscriber.PhoneNumber.ToLower());
* if (isFound)
* {
* return new OutputResponse
* {
* IsErrorOccured = true,
* Message = "Subscriber phone number already exist, duplicates not allowed"
* };
* }*/
var mappedSubscriber = new AutoMapperHelper <SubscriberDTO, Subscribers>().MapToObject(subscriber);
await _context.Subscribers.AddAsync(mappedSubscriber);
await _context.SaveChangesAsync();
return(new OutputResponse
{
IsErrorOccured = false,
Message = MessageHelper.AddNewSuccess
});
}
public async Task <ActionResult <bool> > RegisterAsync(SubscriberDTO subscriberDTO)
{
var subsciber = _mapper.Map <SubscriberModel>(subscriberDTO);
return(await _subscriberService.AddAsync(subsciber, subscriberDTO.height));
}
