public List <Consultant> GetAll()
{
ConsultantDAC _consultantComponent = new ConsultantDAC();
IDataReader reader = _consultantComponent.GetAllConsultant().CreateDataReader();
List <Consultant> _consultantList = new List <Consultant>();
while (reader.Read())
{
if (_consultantList == null)
{
_consultantList = new List <Consultant>();
}
Consultant _consultant = new Consultant();
if (reader["ConsultantId"] != DBNull.Value)
{
_consultant.ConsultantId = Convert.ToInt32(reader["ConsultantId"]);
}
if (reader["ConsultantCode"] != DBNull.Value)
{
_consultant.ConsultantCode = Convert.ToString(reader["ConsultantCode"]);
}
_consultant.NewRecord = false;
_consultantList.Add(_consultant);
}
reader.Close();
return(_consultantList);
}
private async Task <Consultant> CreateConsultantAsync(ConsultantModel model)
{
IFormFile formFile = Request.Form.Files.FirstOrDefault();
var consultant = new Consultant
{
Name = model.FullName,
DateOfBirth = DateTime.Parse(model.DateOfBirth),
EmailAddress = model.EmailAddress,
StreetAddress = model.StreetAddress,
ZipCode = int.Parse(model.ZipCode),
City = model.City,
IsOnAssignment = model.IsOnAssignment,
Skills = model.Skills,
};
if (model.ConsultantId.HasValue)
{
consultant.ConsultantId = model.ConsultantId.Value;
}
if (formFile != null)
{
consultant.ConsultantImage = new ConsultantImage
{
Data = await formFile.GetBufferAsync(),
Name = formFile.Name
};
}
return(consultant);
}
public ActionResult Edit([Bind(Include = "ID,FirstName,LastName,DateOfBirth,IdNumber,Gender,Email,Pais,Address,PhoneNumber,JobTitle,Education,HireDate")] Consultant consultant)
{
ListOfCountries();
if (ModelState.IsValid)
{
try
{
consultantRepo.UpdateConsultant(consultant);
consultantRepo.Save();
return(Json(new { success = true }));
}
catch (DbUpdateException sqlExc)
{
var sqlException = sqlExc.GetBaseException() as SqlException;
if (sqlException != null)
{
ViewBag.Message = "Record already exists.";
}
else
{
throw;
}
}
}
return(PartialView("PartialConsultants/_editConsultant", consultant));
}
private static void CreateConsultant()
{
//Consultant
var consultant = new Consultant
{
FirstName = "Hannes",
LastName = "Lowette",
Birthday = new DateTime(1982, 02, 11)
};
//Certification
var certification = new Certification
{
CertificationCode = "70-433",
Name = "SQL Server 2008 - Database Development"
};
//ResumeItem
var resumeItem = new ResumeItem
{
Certification = certification,
Consultant = consultant,
DateAcquired = new DateTime(2010, 05, 06)
};
//EF via DbContext weg.
var db = new ConsultingContext("Data Source=WIN10DEVMACHINE;Initial Catalog=DemoDatabase;Integrated Security=True");
db.Consultants.Add(consultant);
db.Certifications.Add(certification);
db.ResumeItems.Add(resumeItem);
db.SaveChanges();
}
static void Main(string[] args)
{
//Books
var book1 = new Biography("Napoleon", "Ponasenkov", true);
var book2 = new Comix("Batman", "Marvel", false);
var book3 = new Horror("It", "Steven King", true);
var book4 = new Tutorial("C#", "Microsoft", false);
var book5 = new Horror("Dagon", "Lovecraft", true);
//Employees
var vincent = new Warehouseman("Vicent", 39, 170, 60, 30000);
var jules = new Consultant("Jules", 34, 179, 66, 29000);
var butch = new Cashier("Butch", 28, 180, 58, 20000);
//Clients
var mr_green = new Client("MrGreen", 50, 190, 78, 30000);
var mr_white = new Client("MrWhite", 50, 190, 78, 30000);
var mr_brown = new Client("MrBrown", 50, 190, 78, 30000);
var mr_pink = new Client("MrPink", 50, 190, 78, 30000);
//Boss
var boss = new Owner("Marsellus", 70, 169, 90);
Console.WriteLine("===============");
WorkDay.Start();
}
public async Task <ActionResult <Consultant> > PostConsultant(Consultant consultant)
{
_context.Consultants.Add(consultant);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetConsultant", new { id = consultant.consultantId }, consultant));
}
public void Edit([FromBody] Consultant Consultant)
{
if (ModelState.IsValid)
{
objConsultant.UpdateConsultant(Consultant);
}
}
public void Should_Assign_Names_ToConsultant()
{
var expected = new Consultant("firstName", "lastName");
expected.FirstName.Should().Be("firstName");
expected.LastName.Should().Be("lastName");
}
public void Create([FromBody] Consultant Consultant)
{
if (ModelState.IsValid)
{
objConsultant.AddConsultant(Consultant);
}
}
private static string AddConsultant(HttpClient client)
{
// add consultant
var newConsultant = new Consultant
{
Name = "Brock Allen",
Country = "US",
EmailAddress = "*****@*****.**",
};
"\nAdd new consultant...".ConsoleGreen();
var response = client.PostAsJsonAsync <Consultant>("consultants", newConsultant).Result;
if (response.StatusCode == HttpStatusCode.Created)
{
Console.WriteLine("success.");
Console.WriteLine("location: {0}", response.Headers.Location);
return(response.Headers.Location.OriginalString);
}
else
{
Console.WriteLine("failed.");
Console.WriteLine(response.StatusCode);
return(null);
}
}
public void Counts_consultant_without_missions()
{
//Arrange
var now = DateTime.Now;
var activeConsultant = new Consultant
{
Id = 1,
Missions = new List <Mission> {
new Mission {
Id = 2, StartDate = now.AddDays(-5), EndDate = null
},
new Mission {
Id = 1, StartDate = now.AddDays(-10), EndDate = now.AddDays(-5)
}
}
};
var idleConsultant = new Consultant {
Id = 2
};
var controller = GetDashboardController(new List <Consultant> {
activeConsultant, idleConsultant
});
//Act
var count = controller.GetIdleEmployeeCount();
//Assert
Assert.Equal(1, count);
}
public void Given_consultant_exists_when_Post_then_consultant_is_updated()
{
Consultant savedConsultant = null;
// Given
var consultant = new Consultant() { Id = Guid.NewGuid() };
var model = new ConsultantViewModel() { Id = consultant.Id, Forename = "Stansa", Surname = "Stark", Blacklisted= true, Email="*****@*****.**", QaAdvisorAssigned = Guid.NewGuid()};
var target = GetTarget();
_consultantRepository.Setup(x => x.GetById(consultant.Id))
.Returns(() => consultant);
_consultantRepository.Setup(x => x.SaveOrUpdate(It.IsAny<Consultant>()))
.Callback<Consultant>(x => savedConsultant = x);
// When
target.Post(model);
// Then
Assert.That(savedConsultant.Id, Is.EqualTo(model.Id));
Assert.That(savedConsultant.Forename, Is.EqualTo(model.Forename));
Assert.That(savedConsultant.Surname, Is.EqualTo(model.Surname));
Assert.That(savedConsultant.Email, Is.EqualTo(model.Email));
Assert.That(savedConsultant.QaAdvisorAssigned, Is.EqualTo(model.QaAdvisorAssigned));
Assert.That(savedConsultant.PercentageOfChecklistsToSendToQualityControl, Is.EqualTo(100));
}
private static void UpdateConsultant(HttpClient client, string location)
{
"\nUpdate consultant...".ConsoleGreen();
var newClient = new HttpClient {
BaseAddress = new Uri(location)
};
if (client.DefaultRequestHeaders.Authorization != null)
{
newClient.DefaultRequestHeaders.Authorization = client.DefaultRequestHeaders.Authorization;
}
var updatedConsultant = new Consultant
{
Name = "Brock Allen",
Country = "US",
EmailAddress = "*****@*****.**"
};
var response = newClient.PutAsJsonAsync <Consultant>("", updatedConsultant).Result;
response.EnsureSuccessStatusCode();
ListConsultants(client);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,UserId,ImageUrl,Biography,Language")] Consultant consultant)
{
if (id != consultant.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(consultant);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConsultantExists(consultant.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(consultant));
}
public async Task <Consultant> CreateConsultant(Consultant consultant)
{
_dbContext.Add(consultant);
await _dbContext.SaveChangesAsync();
return(consultant);
}
public Consultant GetByEmail(string email)
{
Consultant consultant = _consultantRepository.Query()
.Where(x => x.EmailAddress == email).FirstOrDefault();
return(_mapper.Map <Consultant>(consultant));
}
public IHttpActionResult PutConsultant(int id, Consultant consultant)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != consultant.Id)
{
return(BadRequest());
}
db.Entry(consultant).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ConsultantExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
static void Main(string[] args)
{
// Triage > Doctor > Consultant.
Triage triage = new Triage();
Doctor doctor = new Doctor();
Consultant consultant = new Consultant();
AdmissionsWard ward = new AdmissionsWard();
Surgery surgery = new Surgery();
triage.SetSuccessor(doctor);
doctor.SetSuccessor(consultant);
consultant.SetSuccessor(ward);
consultant.SetSuccessor(surgery);
Patient p1 = new Patient("Alison", Condition.HeadTrauma);
Patient p2 = new Patient("Brian", Condition.Infection);
Patient p3 = new Patient("Charlie", Condition.GeneralPain);
Patient p4 = new Patient("Diana", Condition.Other);
Patient p5 = new Patient("Edward", Condition.ChestPain);
Patient p6 = new Patient("Frankie", Condition.Injury);
triage.HandlePatient(p1);
Console.WriteLine();
triage.HandlePatient(p2);
Console.WriteLine();
triage.HandlePatient(p3);
Console.WriteLine();
triage.HandlePatient(p4);
Console.WriteLine();
triage.HandlePatient(p5);
Console.WriteLine();
triage.HandlePatient(p6);
Console.ReadKey();
}
public async Task <IHttpActionResult> Update([FromBody] ConsultantUpdateDto consultantUpdateDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
userRepository.Update(consultantUpdateDto.User);
consultantRepository.Update(consultantUpdateDto.ConsultantUpdateDtoToConsultant());
try {
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException) {
Consultant consultantToUpdate = await consultantRepository.FindByCondition(item => item.Id == consultantUpdateDto.Id).FirstOrDefaultAsync();
if (consultantToUpdate == null)
{
return(Content(HttpStatusCode.NotFound, "Consultant not found"));
}
User userToUpdate = await userRepository.FindByCondition(item => item.Id == consultantUpdateDto.User.Id).FirstOrDefaultAsync();
if (userToUpdate == null)
{
return(Content(HttpStatusCode.NotFound, "User not found"));
}
throw;
}
return(Ok());
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Email,AgencyId")] Consultant consultant)
{
if (id != consultant.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(consultant);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConsultantExists(consultant.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AgencyId"] = new SelectList(_context.Agency, "Id", "Id", consultant.AgencyId);
return(View(consultant));
}
public bool Insert(ConsultantModel consultantModel)
{
return(LogIfOperationFailed(() =>
{
Consultant consultant = ConsultantMapper.ConvertModelToEntity(consultantModel);
_unitOfWork.ConsultantRepository.InsertOrUpdate(consultant);
_unitOfWork.Commit();
var existingProviderConsultant = _unitOfWork.ProviderConsultantRepository.GetAll.Where(m => m.ConsultantId == consultant.Id).ToList();
foreach (var ProviderConsultant in existingProviderConsultant)
{
_unitOfWork.ProviderConsultantRepository.Delete(ProviderConsultant.Id);
}
_unitOfWork.Commit();
if (consultantModel.ConsultantProviderIds != null)
{
foreach (var providerId in consultantModel.ConsultantProviderIds)
{
var providerConsultant = new ProviderConsultant();
providerConsultant.ConsultantId = consultant.Id;
providerConsultant.ProviderId = providerId;
_unitOfWork.ProviderConsultantRepository.InsertOrUpdate(providerConsultant);
}
}
_unitOfWork.Commit();
return true;
}, Resources.ExceptionInsertConsultant, consultantModel.Name));
}
internal async Task <ResponseModel> EndConsultant(Consultant source, int loginId)
{
ResponseModel response = new ResponseModel();
using (IDbConnection conn = _dbConnection.Connection)
{
DynamicParameters param = new DynamicParameters();
param.Add("@ConsultantId", source.consultantid, DbType.Int32);
param.Add("@EndDate", Convert.ToDateTime(source.enddate).ToString("yyyy-MM-dd"), DbType.Date);
param.Add("@ShouldEndClient", true, DbType.Boolean);
param.Add("@LoginId", loginId, DbType.Int32);
var data = await conn.QueryAsync <int>(Constants.StoredProcedure.UPDATECONSULTANT, param, null, null, CommandType.StoredProcedure);
int result = 0;
if (data.ToList().Count > 0)
{
result = data.ToList()[0];
}
response.ResultStatus = result;
response.RequestType = Constants.RequestType.POST;
response.SuccessMessage = result == 0 ? string.Empty : "Consultant saved successfully.";
response.ErrorMessage = result == 0 ? "Error occurred while saving. Please try again." : string.Empty;
}
return(response);
}
public async Task <ActionResult <AddressViewModel> > Get(int id, bool includeConsultant = false)
{
try
{
Address result = await repository.GetAddressAsync(id);
if (result == null)
{
return(NotFound());
}
if (includeConsultant)
{
AddressViewModel address = mapper.Map <AddressViewModel>(result);
Consultant resultConsultant = await repository.GetConsultantAsync(result.ConsultantId, false);
//TODO When repo is called from here it always returns with addresses
resultConsultant.Addresses = null;
address.consultant = mapper.Map <ConsultantViewModel>(resultConsultant);;
return(address);
}
else
{
return(mapper.Map <AddressViewModel>(result));
}
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Error in database"));
}
}
protected override async Task OnParametersSetAsync()
{
if (action == "fetch")
{
await FetchConsultant();
this.StateHasChanged();
}
else if (action == "create")
{
title = "Adicionar Consultor";
consultant = new Consultant();
}
else if (paramConsultantID != "0")
{
if (action == "edit")
{
title = "Editar Consultor";
}
else if (action == "delete")
{
title = "Remover Consultor";
}
consultant = await Http.GetJsonAsync <Consultant>("/api/Consultant/Details/" + Convert.ToInt32(paramConsultantID));
}
}
// GET: Consultants/Edit/5
public ActionResult Edit(int id)
{
ListOfCountries();
Consultant consultant = consultantRepo.GetConsultantByID(id);
return(PartialView("PartialConsultants/_editConsultant", consultant));
}
// Helper methods for creating user objects from a data reader.
private User ReadUserRow(SqlDataReader reader)
{
User user = null;
// UserType is a discriminator column on the user table.
string userType = reader.Field <string>("UserType");
if (userType == AccountTypes.CONSULTANT)
{
var consultant = new Consultant();
consultant.IsOnBeach = reader.Field <bool>("IsOnBeach");
user = consultant;
}
else if (userType == AccountTypes.ACCOUNT_EXECUTIVE)
{
user = new AccountExecutive();
}
user.Id = reader.Field <int>("Id");
user.EmailAddress = reader.Field <string>("EmailAddress");
user.FirstName = reader.Field <string>("FirstName");
user.LastName = reader.Field <string>("LastName");
user.PhoneNumber = new PhoneNumber(reader.Field <string>("PhoneNumber"));
user.Password = new HashedPassword();
user.Password.Hash = reader.Field <string>("Password_Hash");
user.Password.Salt = reader.Field <string>("Password_Salt");
return(user);
}
public async Task <IActionResult> PutConsultant(int id, Consultant consultant)
{
if (id != consultant.consultantId)
{
return(BadRequest());
}
_context.Entry(consultant).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConsultantExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
// GET: Consultants/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Consultant consultant = db.Consultants.Find(id);
if (consultant == null)
{
return(HttpNotFound());
}
ConsultantViewModel model;
model = new ConsultantViewModel
{
Id = consultant.Id,
Name = consultant.Name,
Phone = consultant.Phone,
Email = consultant.Email,
Address = consultant.Address,
DeptId = consultant.DeptId,
Status = consultant.Status
};
ViewBag.DepartmentsList = db.Departments.ToList();
return(View(model));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Description,DisplayName,ImgName")] Consultant consultant, IFormFile file)
{
UploadFile(file, _env);
consultant.ImgName = Fotonaam;
if (id != consultant.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(consultant);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConsultantExists(consultant.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(consultant));
}
public void DeleteConsultant(int consultantId)
{
Consultant selectedConsultant = _context.Consultants.Find(consultantId);
_context.Consultants.Remove(selectedConsultant);
_context.SaveChanges();
}
public async Task LoadSession()
{
if (CacheProvider.IsSet(CacheKey.LoggedConsultant))
{
consultant = CacheProvider.Get <Consultant> (CacheKey.LoggedConsultant);
return;
}
ConsultantSession conSession =
SessionFactory.ReadSession <ConsultantSession>(SessionKeys.LoggedConsultant);
// may consultant session na, so kunin nalang natin ung info nya.
if (conSession != null && conSession.IsSet)
{
consultant = await conService.GetConsultantByUsername(conSession.Username);
}
// i-load muna ung consultant session from account session
ConsultantSessionLoader conLoader = new ConsultantSessionLoader(conService);
bool isLoaded = await conLoader.LoadConsultantSession();
if (isLoaded)
{
consultant = conLoader.LoadedConsultant;
CacheProvider.Set(CacheKey.LoggedConsultant, consultant);
}
}
public IEnumerable<Consultant> DeleteConsultant(Consultant consultant, string token)
{
if (!IsConnected(token))
{
throw new NotConnectedException();
}
return ConsultantDAL.DeleteConsultant(consultant);
}
public void Given_consultant_exists_when_Delete_then_consultant_deleted()
{
Consultant savedConsultant = null;
// Given
var consultant = new Consultant() { Id = Guid.NewGuid() };
var model = new ConsultantViewModel() { Id = consultant.Id, Forename = "Stansa", Surname = "Stark", Blacklisted= true, Email="*****@*****.**", QaAdvisorAssigned = Guid.NewGuid()};
var target = new ConsultantController(_dependencyFactory.Object);
_consultantRepository.Setup(x => x.GetById(consultant.Id))
.Returns(() => consultant);
_consultantRepository.Setup(x => x.SaveOrUpdate(It.IsAny<Consultant>()))
.Callback<Consultant>(x => savedConsultant = x);
// When
target.Delete(consultant.Id);
// Then
Assert.That(savedConsultant.Id, Is.EqualTo(model.Id));
Assert.That(savedConsultant.Deleted, Is.EqualTo(true));
}
public void Given_consultants_when_Get_then_returns_the_correct_view_model()
{
// Given
var consultant = new Consultant() { Id = Guid.NewGuid(), Forename = "Ayra", Surname = "Stark", Deleted = false,
Email = "*****@*****.**", PercentageOfChecklistsToSendToQualityControl = 100, QaAdvisorAssigned = Guid.NewGuid() };
_consultantRepository
.Setup(x => x.GetAll())
.Returns(() => new List<Consultant>() { consultant });
var target = new ConsultantController(_dependencyFactory.Object);
// When
var result = target.Get();
// Then
Assert.That(result[0].Id, Is.EqualTo(consultant.Id));
Assert.That(result[0].Forename, Is.EqualTo(consultant.Forename));
Assert.That(result[0].Surname, Is.EqualTo(consultant.Surname));
Assert.That(result[0].Fullname , Is.EqualTo(consultant.FullName));
Assert.That(result[0].Email , Is.EqualTo(consultant.Email));
Assert.That(result[0].QaAdvisorAssigned, Is.EqualTo(consultant.QaAdvisorAssigned));
Assert.That(result[0].Blacklisted, Is.True);
}
static void Main(string[] args)
{
var sully = new Sully();
sully.SetLocation("Catapult Office");
var landon = new ProjectManager("Landon");
var david = new Consultant("David");
var john = new Consultant("John");
Console.ReadLine();
sully.AddObserver(landon);
sully.AddObserver(david);
sully.AddObserver(john);
sully.SetLocation("Starbucks");
Console.ReadLine();
sully.RemoveObserver(david);
sully.SetLocation("Catalina");
Console.ReadLine();
sully.RemoveObserver(john);
var greg = new Consultant("Greg");
sully.AddObserver(greg);
sully.SetLocation("It's a Grind");
Console.ReadLine();
}
public CDSResponse PostOrderData(Consultant consultant, Customer customer, Order order)
{
var baseAddress = new Uri(_appSettings.GetValue("CDS.BaseCheckoutUrl"));
var cookieContainer = new CookieContainer();
cookieContainer.Add(baseAddress, GetAuthCookie(_appSettings.GetValue("CDS.CookieDomain")));
using (var handler = new HttpClientHandler() { CookieContainer = cookieContainer, Proxy = WebRequest.DefaultWebProxy })
using (var client = new HttpClient(handler) { BaseAddress = baseAddress })
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var formData = GetFormData(consultant, customer, order);
var content = new FormUrlEncodedContent(formData);
_logger.Trace("CDS Handshake Request: {0}", content);
var postTask = client.PostAsync(_appSettings.GetValue("CDS.HandshakeUrl"), content);
postTask.Wait();
var postResult = postTask.Result;
postResult.EnsureSuccessStatusCode();
var readTask = postResult.Content.ReadAsStringAsync();
readTask.Wait();
var json = readTask.Result;
_logger.Trace("CDS Handshake Response: {0}", json);
try
{
var result = JsonConvert.DeserializeObject<CDSResult>(json, new IsoDateTimeConverter());
return result.Response;
}
catch (JsonReaderException)
{
_logger.Error("Failed to parse CDS response:\r\n{0}", json);
throw;
}
}
}
public void Given_username_exist_and_consultant_record_is_deleted_when_Post_then_consultant_restored()
{
// Given
Consultant savedConsultant = null;
var adUser = new User() { EmailAddress = "*****@*****.**", Forename = "Casey", Surname = "Stone" };
var consultant = new Consultant() {Id = Guid.Parse("744905F7-62DC-4113-BB45-644E58F02D6A"), Deleted = true, Email = "*****@*****.**"};
var model = new ConsultantViewModel() { Id = Guid.NewGuid(), Username = "******" };
var target = GetTarget();
_consultantRepository.Setup(x => x.GetById(It.IsAny<Guid>()))
.Returns(() => null);
_consultantRepository.Setup(x => x.GetByUsername(model.Username, true))
.Returns(() => consultant);
_consultantRepository.Setup(x => x.SaveOrUpdate(It.IsAny<Consultant>()))
.Callback<Consultant>(x => savedConsultant = x);
_activeDirectoryService.Setup(x => x.DoesUserExist(It.IsAny<string>()))
.Returns(true);
_activeDirectoryService.Setup(x => x.GetUser(It.IsAny<string>()))
.Returns(() => adUser);
// When
var result = target.Put(model.Username);
// Then
Assert.That(savedConsultant.Deleted, Is.False);
Assert.That(savedConsultant.Email, Is.EqualTo(adUser.EmailAddress));
Assert.That(savedConsultant.Id, Is.EqualTo(consultant.Id));
}
void SetCookies(Consultant consultant, string culture, string uiCulture)
{
var roles = new List<string>();
if (consultant.Roles != null && consultant.Roles.Count > 0)
roles = (from s in consultant.Roles select s.RoleName).ToList();
roles.Add("Corporate");
var now = DateTime.Now;
var ticket = new FormsAuthenticationTicket(1, consultant.ID.ToString(), now, now.AddDays(1), false, string.Join(";", roles.ToArray()));
SetCookie(FormsAuthentication.FormsCookieName, FormsAuthentication.Encrypt(ticket));
SetCookie("culture", culture.ToString());
SetCookie("uiculture", uiCulture.ToString());
SetCookie("subsidiary", consultant.SubsidiaryCode);
}
public BindingList<Timesheet> GetTimesheets(Consultant consultant, DateTime startRange, DateTime endRange);
public void Setup()
{
_consultant = Consultant.Create("Tywin", "Lannister");
_bus = new Mock<IBus>();
_clientDetailsService = new Mock<IClientDetailsService>();
_dependencyFactory = new Mock<IDependencyFactory>();
_consultantRepo = new Mock<IConsultantRepository>();
_consultantRepo.Setup(x=> x.GetByFullname(It.IsAny<string>()))
.Returns(() => _consultant);
_getCompletedChecklistQuery = new Mock<IGetCompleteChecklistsQuery>();
_dependencyFactory.Setup(x => x.GetInstance<IBus>())
.Returns(() => _bus.Object);
_dependencyFactory.Setup(x => x.GetInstance<IConsultantRepository>())
.Returns(() => _consultantRepo.Object);
_dependencyFactory.Setup(x => x.GetInstance<IGetCompleteChecklistsQuery>())
.Returns(() => _getCompletedChecklistQuery.Object);
}
public void Setup()
{
_consultant = Consultant.Create("Tywin", "Lannister");
_qaAdvisor = QaAdvisor.Create("Jon", "Stark", "*****@*****.**");
_qaAdvisor.Id = Guid.NewGuid();
_bus = new Mock<IBus>();
_clientDetailsService = new Mock<IClientDetailsService>();
_dependencyFactory = new Mock<IDependencyFactory>();
_consultantRepo = new Mock<IConsultantRepository>();
_lastQaAdvisorAssignedRepo = new Mock<IRepository<LastQaAdvisorAssigned, int>>();
_qaAdvisorRepo = new Mock<IQaAdvisorRepository>();
_consultantRepo.Setup(x=> x.GetByFullname(It.IsAny<string>()))
.Returns(() => _consultant);
_qaAdvisorRepo.Setup(x => x.GetById(It.IsAny<Guid>()))
.Returns(() => _qaAdvisor);
_getCompletedChecklistQuery = new Mock<IGetCompleteChecklistsQuery>();
_dependencyFactory.Setup(x => x.GetInstance<IBus>())
.Returns(() => _bus.Object);
_dependencyFactory.Setup(x => x.GetInstance<IConsultantRepository>())
.Returns(() => _consultantRepo.Object);
_dependencyFactory.Setup(x => x.GetInstance<IGetCompleteChecklistsQuery>())
.Returns(() => _getCompletedChecklistQuery.Object);
_dependencyFactory.Setup(x => x.GetInstance<IRepository<LastQaAdvisorAssigned, int>>())
.Returns(() => _lastQaAdvisorAssignedRepo.Object);
_dependencyFactory.Setup(x => x.GetInstance<IQaAdvisorRepository>())
.Returns(() => _qaAdvisorRepo.Object);
}
public TermsController(IConsultantDataServiceClientFactory clientFactory, IConsultantContext consultantContext, IAppSettings appSettings)
{
_clientFactory = clientFactory;
_consultant = consultantContext.Consultant;
_appSettings = appSettings;
}
IEnumerable<KeyValuePair<string, string>> GetFormData(Consultant consultant, Customer customer, Order order)
{
if (consultant == null) throw new ArgumentNullException("consultant");
if (customer == null) throw new ArgumentNullException("customer");
if (order == null) throw new ArgumentNullException("order");
if (order.Items == null || order.Items.Length == 0) throw new InvalidOperationException("Order contains no items");
if (order.ShippingAddress == null) throw new InvalidOperationException("Order.ShippingAddress not specified.");
var customerName = string.Format("{0} {1}", customer.ContactInformation.FirstName, customer.ContactInformation.LastName);
var shippingAddress = order.ShippingAddress;
var formData = new Dictionary<string, string>
{
{ "order_id", order.OrderId.ToString() },
{ "order_type", "salesticket" },
{ "purchaser_id", consultant.ConsultantID },
{ "purchaser_firstname", consultant.FirstName },
{ "purchaser_lastname", consultant.LastName },
{ "customer_id", customer.LegacyContactId.HasValue ? customer.LegacyContactId.Value.ToString() : string.Empty },
{ "customer_key", customer.CustomerId.ToString() },
{ "customer_firstName", customer.ContactInformation.FirstName },
{ "customer_lastName", customer.ContactInformation.LastName },
{ "customer_emailAddress", customer.EmailAddress != null ? customer.EmailAddress.Address : string.Empty },
{ "customer_language", customer.ContactPreferences.PreferredLanguage ?? string.Empty },
{ "shipto_name", !string.IsNullOrWhiteSpace(shippingAddress.Addressee) ? shippingAddress.Addressee : customerName },
{ "shipto_streetAddress", shippingAddress.Street },
{ "shipto_addressLine2", shippingAddress.UnitNumber },
{ "shipto_city", shippingAddress.City },
{ "shipto_state", shippingAddress.RegionCode },
{ "shipto_zip", shippingAddress.PostalCode },
{ "shipto_phone", shippingAddress.Telephone },
{ "billto_name", customerName },
{ "billto_address", shippingAddress.Street },
{ "billto_zip", shippingAddress.PostalCode },
};
if (order.GiftMessage != null && order.GiftMessage.IsGift)
formData.Add("gift_message", order.GiftMessage.Message);
for (var i = 0; i < order.Items.Length; i += 1)
{
var orderItem = order.Items[i];
if (string.IsNullOrWhiteSpace(orderItem.PartId))
throw new InvalidOperationException("Order.Items[" + i.ToString() + "].PartId not specified.");
if (i == 0)
{
formData.Add("item_sku", orderItem.PartId);
formData.Add("item_quantity", orderItem.Quantity.ToString());
}
else
{
formData.Add(string.Format("item_sku{0}", i + 1), orderItem.PartId);
formData.Add(string.Format("item_quantity{0}", i + 1), orderItem.Quantity.ToString());
}
}
if (order.Payments != null)
{
var ccPayments = order.Payments.Where(p => p.PaymentType.HasValue && p.PaymentType.Value == PaymentType.CreditCard).ToArray();
if (ccPayments.Length > 1) throw new InvalidOperationException("Orders with more than on credit card payment cannot be sent to CDS.");
if (ccPayments.Length != 0)
{
var payment = ccPayments[0];
if (payment.PaymentStatus == PaymentStatus.Approved || payment.PaymentStatus == PaymentStatus.Declined || payment.PaymentStatus == PaymentStatus.Error)
throw new InvalidOperationException("Existing credit card payment has an invalid status for CDS");
var creditCard = payment.CreditCard;
if (creditCard != null)
{
var expirationDate = new DateTime(Convert.ToInt32(creditCard.ExpYear), Convert.ToInt32(creditCard.ExpMonth), 1).AddMonths(1).AddDays(-1).ToString("M/d/yyyy");
formData.Add("billto_ccBrand", ((int)creditCard.Type).ToString());
formData.Add("billto_ccDisplayNumber", creditCard.Last4Digits);
formData.Add("billto_ccToken", creditCard.Token);
formData.Add("billto_expirationDate", expirationDate);
}
}
}
return formData;
}
string EncryptVMOUserNameString(Consultant consultant, Customer customer, string projectKey = "3")
{
string vmoTag = @"<vmo username=""{0};{1};{2}"" project=""{3}"" userlevel=""{4}"" />";
string vmoTagFormatted = String.Format(vmoTag,
consultant.ConsultantID,
customer.LegacyContactId.HasValue ? customer.LegacyContactId.Value.ToString() : customer.CustomerId.ToString(),
consultant.SubsidiaryCode,
projectKey,
"3");
string encryptedUserName = VMOEncryption.Encrypt(vmoTagFormatted);
return encryptedUserName;
}
