public async Task <IActionResult> Submit(RecipientViewModel model)
{
if (!ModelState.IsValid)
{
model.RecipientGroups = await _emailDistributionService.GetEmailRecipientGroups();
return(View("Index", model));
}
List <int> recipientGroupIds;
if (model.SelectedGroupIds.Any(x => x == 0))
{
var groups = await _emailDistributionService.GetEmailRecipientGroups();
recipientGroupIds = groups.Select(x => x.RecipientGroupId).ToList();
}
else
{
recipientGroupIds = model.SelectedGroupIds.ToList();
}
var newRecipients = model.Email.Split(";");
foreach (var newRecipient in newRecipients)
{
var recipient = new Recipient()
{
EmailAddress = newRecipient,
RecipientGroupIds = recipientGroupIds
};
var httpRawResponse = await _emailDistributionService.SaveRecipientAsync(recipient);
if (httpRawResponse.StatusCode == (int)HttpStatusCode.Conflict)
{
var recipientGroups =
_jsonSerializationService.Deserialize <List <RecipientGroup> >(httpRawResponse.Content);
if (recipient.RecipientGroupIds.All(
x => recipientGroups.Select(y => y.RecipientGroupId).Contains(x)))
{
AddError(ErrorMessageKeys.Recipient_EmailFieldKey, $"Email {newRecipient} already exists in the selected distribution groups");
AddError(ErrorMessageKeys.ErrorSummaryKey, $"Email {newRecipient} already exists in the selected distribution groups");
}
else
{
AddError(ErrorMessageKeys.WarningSummaryKey, $"Email {newRecipient} already associated to some of the distribution groups selected. Non-associated have been successfully added.");
model.IsAdd = true;
}
}
else
{
model.IsAdd = true;
}
}
model.RecipientGroups = await _emailDistributionService.GetEmailRecipientGroups();
return(View("Index", model));
}
public void Create(RecipientViewModel model)
{
TicketRecipient data = config.CreateMapper().Map <RecipientViewModel, TicketRecipient>(model);
context.TicketRecipients.Add(data);
context.SaveChanges();
}
public IActionResult AddRecipient(RecipientViewModel recipientView)
{
var recipientmetadata = new CreateRecipientMetadata()
{
job = recipientView.job
};
var newrecipient = new CreateRecipientRequestModel()
{
type = "nuban",
name = recipientView.name,
account_number = recipientView.account_number,
bank_code = recipientView.bank_code,
currency = "NGN",
metadata = recipientmetadata
};
var result = _recipent.AddRecipient(newrecipient);
var message = result.Result.Result.message;
if (result.Result.Result.status == "true")
{
TempData["notification"] = "Recipient Added Successfully";
TempData["notifytype"] = NotificationType.success;
}
else
{
TempData["notification"] = message;
TempData["notifytype"] = NotificationType.error;
}
return(RedirectToAction("Index"));
}
public IHttpActionResult PutRecipient(RecipientViewModel recipient)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid data."));
}
using (var ctx = new SklepEntities())
{
var ExistingRecipient = ctx.Odbiorcy.Where(I => I.Odbiorca_id == recipient.RecipientId).FirstOrDefault();
if (ExistingRecipient != null)
{
ExistingRecipient.Odbiorca_id = recipient.RecipientId;
ExistingRecipient.Odbiorca_nazwa = recipient.RecipientName;
ExistingRecipient.Kraj_id = recipient.RecipientCountryId;
ctx.SaveChanges();
}
else
{
return(NotFound());
}
}
return(Ok());
}
public ActionResult EditRecipient(RecipientViewModel recipient)
{
recipient.CountryList = Recipient.CountryList;
try
{
if (ModelState.IsValid)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(Request.Url.GetLeftPart(UriPartial.Authority));
var putTask = client.PutAsJsonAsync <RecipientViewModel>("api/Recipient", recipient);
putTask.Wait();
var result = putTask.Result;
if (result.IsSuccessStatusCode)
{
logger.Info(Environment.NewLine + "Recipient " + recipient.RecipientId + " editted by " + CookieHandler.GetUserNameFromCookie("LoginCookie") + " " + DateTime.Now);
return(RedirectToAction("RecipientIndex"));
}
}
}
}catch (DataException)
{
}
PopulateList();
return(View(recipient));
}
public ActionResult CreateRecipient(RecipientViewModel recipient)
{
PopulateList();
if (CheckIfDuplicatedId(recipient))
{
return(RedirectToAction("RecipientIndex"));
}
try
{
if (ModelState.IsValid)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(Request.Url.GetLeftPart(UriPartial.Authority));
var postTask = client.PostAsJsonAsync <RecipientViewModel>("api/recipient", recipient);
postTask.Wait();
var result = postTask.Result;
if (result.IsSuccessStatusCode)
{
logger.Info(Environment.NewLine + "Recipient " + recipient.RecipientId.ToString() + " added by " + CookieHandler.GetUserNameFromCookie("LoginCookie") + " " + DateTime.Now);
return(RedirectToAction("RecipientIndex"));
}
}
}
}
catch (DataException)
{
ModelState.AddModelError(string.Empty, "Cannot create recipient");
}
PopulateList();
return(View(recipient));
}
protected void AddRecipient()
{
var newRecipient = new RecipientViewModel();
newRecipient.SetAsNew();
Recipients.Insert(0, newRecipient);
}
public IActionResult DeleteConfirmed(int id)
{
RecipientViewModel recipient = recipientManager.GetRecipientById(id);
int companyId = recipient.CompanyId;
recipientManager.Delete(id);
return(RedirectToAction("Index", "Recipient", new { companyId }));
}
public async Task <IActionResult> Index()
{
var model = new RecipientViewModel();
model.RecipientGroups = await _emailDistributionService.GetEmailRecipientGroups();
return(View("Index", model));
}
public void Update(RecipientViewModel model)
{
TicketRecipient data = context.TicketRecipients.Find(model.TicketRecipientId);
data.EmailAddress = model.EmailAddress;
data.PhoneNumber = model.PhoneNumber;
data.Title = model.Title;
context.SaveChanges();
}
private bool CheckIfDuplicatedId(RecipientViewModel recipient)
{
if (Recipients.Where(c => c.RecipientId.Trim().Equals(recipient.RecipientId.Trim(), StringComparison.OrdinalIgnoreCase)).SingleOrDefault() != null)
{
TempData["error"] = "Cannot create. ID must be unique.";
return(true);
}
return(false);
}
public ActionResult Edit(RecipientViewModel model)
{
if (ModelState.IsValid)
{
repo.Update(model);
return(RedirectToAction("Index"));
}
return(View(model));
}
public IActionResult Delete(int id)
{
RecipientViewModel recipient = recipientManager.GetRecipientById(id);
if (recipient == null)
{
return(NotFound());
}
return(View(recipient));
}
protected async Task VerifyRecipient(RecipientViewModel recipientModel)
{
recipientModel.IsVerifying = true;
var result = await WorkerCommunicationProxy.ProbeRecipient(recipientModel.Address);
recipientModel.Verified = !string.IsNullOrEmpty(result.hostname);
recipientModel.VerifyResult = result.exception;
recipientModel.Name = result.hostname;
recipientModel.IsVerifying = false;
StateHasChanged();
}
public void TestRemoveRecipient()
{
MessageViewModel mvm = new MessageViewModel();
Address addr = new Address();
RecipientViewModel rvm = mvm.AddRecipient(addr);
mvm.RemoveRecipient(rvm);
Assert.AreEqual(0, mvm.Recipients.Count);
}
protected override void Initialize()
{
manager = new RecipientManager(mockUnitOfWork.Object, mockMapper.Object);
item = new Recipient()
{
Id = 1, PhoneId = 1, Name = "Test", CompanyId = 1
};
model = new RecipientViewModel()
{
Id = 1, Name = "Test", CompanyId = 1, Phonenumber = "+380661660777"
};
}
public IActionResult Edit(int id, [Bind] RecipientViewModel recipient)
{
RecipientViewModel recipientToEdit = recipientManager.GetRecipientById(id);
int companyId = recipientToEdit.CompanyId;
recipient.CompanyId = companyId;
if (ModelState.IsValid)
{
recipientManager.Update(recipient);
return(RedirectToAction("Index", "Recipient", new { companyId }));
}
return(View(recipient));
}
public ActionResult Recipient()
{
RecipientViewModel vm = new RecipientViewModel();
using (new UnitOfWork.UnitOfWorkScope <BankingDbContext>(UnitOfWork.UnitOfWorkScopePurpose.Reading))
{
AuthenticationService authenticate = new AuthenticationService();
var userEmail = (string)HttpContext.Session["User"];
var user = authenticate.GetUser(userEmail);
vm.UserName = user.Name;
vm.SelectedList = PopulateList();
}
return(View(vm));
}
public IActionResult Edit(int id)
{
var query = _recipientRepository.FindBy(x => x.Id == id);
var model = new RecipientViewModel()
{
Id = query.Id,
EmailAddress = query.EmailAddress,
Department = query.Department
};
ViewBag.DepartmentList = new SelectList(Departments(), "DepartmentName", "DepartmentName");
return(View(model));
}
public IActionResult Create()
{
var users = userServices.GetAllUsers();
var recModel = new RecipientViewModel
{
Users = users
};
var model = new CreatePackageInputModel
{
Recipients = recModel
};
return(View(model));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
RecipientViewModel model = repo.Get(id);
if (model == null)
{
return(HttpNotFound());
}
return(View(model));
}
public ReturnData <List <RecipientViewModel> > GetMessageRecepients(string userName)
{
var users = new List <RecipientViewModel>();
var isGenesis = _studentServices.CheckIfGenesis().Success;
string connetionString = DbSetting.ConnectionString(_configuration, "Unisol");
SqlConnection connection = new SqlConnection(connetionString);
connection.Open();
string sql = "SELECT AdmnNo as username,[names] as fullname FROM Register" +
" UNION" +
" SELECT EmpNo as username,[Names] as fullname FROM hrpEmployee order by fullname asc";
if (isGenesis)
{
sql = "SELECT EmpNo as username,[Names] as fullname FROM hrpEmployee order by fullname asc";
}
SqlCommand command = new SqlCommand(sql, connection);
var listActiveColumns = new List <string>();
using (var rdr = command.ExecuteReader())
{
while (rdr.Read())
{
var newUser = new RecipientViewModel
{
UserName = rdr.GetValue(0).ToString(),
RecipientName = rdr.GetValue(1).ToString()
};
users.Add(newUser);
}
}
var distinctUsers = users.GroupBy(u => u.UserName).Select(u => u.First()).ToList();
command.Dispose();
connection.Close();
return(new ReturnData <List <RecipientViewModel> >
{
Data = distinctUsers,
Success = true,
Message = "Recipients found",
});
}
public IHttpActionResult PostNewRecipient(RecipientViewModel recipient)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid data."));
}
using (var ctx = new SklepEntities())
{
ctx.Odbiorcy.Add(new Odbiorcy()
{
Odbiorca_id = recipient.RecipientId,
Odbiorca_nazwa = recipient.RecipientName,
Kraj_id = recipient.RecipientCountryId
}); ctx.SaveChanges();
}
return(Ok());
}
public IActionResult Create([Bind] RecipientViewModel item, int companyId)
{
if (companyId != 0)
{
TempData["companyId"] = companyId;
}
TempData.Keep("companyId");
bool IsRecipientPhoneExist = recipientManager.GetRecipients(companyId).Any(r => r.Phonenumber == item.Phonenumber);
if (IsRecipientPhoneExist)
{
ModelState.AddModelError("PhoneNumber", "Recipient with this number already exists");
}
if (ModelState.IsValid)
{
recipientManager.Insert(item, (int)TempData.Peek("companyId"));
return(RedirectToAction("Index", "Recipient", new { companyId = (int)TempData.Peek("companyId") }));
}
return(View(item));
}
public IEnumerable <RecipientViewModel> All(string userId)
{
var recipients = this.db.Receipts.Where(r => r.RecipientId == userId).ToList();
var collection = new List <RecipientViewModel>();
foreach (var rec in recipients)
{
var recipt = new RecipientViewModel()
{
Id = rec.Id,
Fee = rec.Fee,
IssuedOn = rec.IssuedOn,
Recipient = this.userService.CurrentUsername(rec.RecipientId)
};
collection.Add(recipt);
}
return(collection);
}
/// <summary>
/// Method for updating recipient in db, and check Phone table, if phone doesn't exist - adding it to Phones
/// </summary>
/// <param name="item">ViewModel of recipient</param>
public bool Update(RecipientViewModel item)
{
Recipient recipient = mapper.Map <RecipientViewModel, Recipient>(item);
List <Phone> phone = unitOfWork.Phones.Get(p => p.PhoneNumber == item.Phonenumber).ToList();
if (phone.Count == 0)
{
Phone newPhone = new Phone();
newPhone.PhoneNumber = item.Phonenumber;
unitOfWork.Phones.Insert(newPhone);
unitOfWork.Save();
recipient.Phone = newPhone;
}
else
{
recipient.PhoneId = phone[0].Id;
}
unitOfWork.Recipients.Update(recipient);
unitOfWork.Save();
return(true);
}
public ActionResult Recipient(RecipientViewModel vm)
{
using (var unitOfWork = new UnitOfWork.UnitOfWorkScope <BankingDbContext>(UnitOfWork.UnitOfWorkScopePurpose.Writing))
{
AuthenticationService authenticate = new AuthenticationService();
var userEmail = (string)HttpContext.Session["User"];
var user = authenticate.GetUser(userEmail);
vm.UserName = user.Name;
if (ModelState.IsValid && vm.Name != null)
{
vm.SelectedList = PopulateList();
try
{
var account =
_efrAccount.GetDbSet()
.Where(x => x.User.Id == user.Id)
.Where(x => x.AccountType == vm.AccountType)
.Include(m => m.TransactionList)
.First();
var recipient =
_efrRecipient.GetDbSet()
.Where(x => x.User.Id == user.Id)
.Where(x => x.Name == vm.Name)
.First();
recipient.Balance += vm.Amount;
account.TransactionList.Add(new Transaction(vm.Amount, TransactionType.WITHDRAW.ToString(),
DateTime.Now));
vm.Message = "Transaction successful with Recipient";
}
catch (Exception)
{
// ignored
}
unitOfWork.SaveChanges();
}
}
return(View(vm));
}
public async Task <IActionResult> Update(RecipientViewModel recipient)
{
if (ModelState.IsValid)
{
var model = new Recipient()
{
Id = recipient.Id,
EmailAddress = recipient.EmailAddress,
Department = recipient.Department
};
try
{
_unitOfWork.BeginTransaction();
await _recipientRepository.Save(model);
await _unitOfWork.Commit();
}
catch (Exception ex)
{
await _unitOfWork.Rollback();
throw ex;
}
finally
{
_unitOfWork.CloseTransaction();
}
return(Redirect("/Recipients/List"));
}
ViewBag.DepartmentList = new SelectList(Departments(), "DepartmentName", "DepartmentName");
return(View("Edit"));
}
protected void DeleteRecipient(RecipientViewModel recipientModel)
{
_toDeleteRecipients.Add(recipientModel);
Recipients.Remove(recipientModel);
}
public void EmailValidationTest(string email, bool expectation)
{
RecipientViewModel model = new RecipientViewModel();
model.IsValidEmail(email).Should().Be(expectation);
}
