public async Task SearchOrganisationBySearchParamsReturnsOrganisationsInTheSortOrderSpecified()
{
var session = EntityHelpers.CreateSession("Admin");
DatabaseContext.Sessions.Add(session);
Client.DefaultRequestHeaders.Add("Cookie", $"access_token={session.Payload}");
var rand = new Random();
var organisations = EntityHelpers.CreateOrganisations(10).ToList();
var searchParam = Randomm.Word();
var first = rand.Next(10, 20);
var second = rand.Next(20, 30);
organisations[5].Name = searchParam + first;
organisations[3].Name = searchParam + second;
DatabaseContext.Organisations.AddRange(organisations);
DatabaseContext.SaveChanges();
var requestUri = new Uri($"api/v1/organisations?search={searchParam}&sort=name&direction=asc", UriKind.Relative);
var response = await Client.GetAsync(requestUri).ConfigureAwait(true);
response.StatusCode.Should().Be(200);
var content = response.Content;
var stringResponse = await content.ReadAsStringAsync().ConfigureAwait(true);
var deserializedBody = JsonConvert.DeserializeObject <OrganisationResponseList>(stringResponse);
deserializedBody.Should().NotBeNull();
deserializedBody.Organisations[0].Name.Should().BeEquivalentTo(organisations[5].Name);
deserializedBody.Organisations[1].Name.Should().BeEquivalentTo(organisations[3].Name);
}
public async Task GivenRequestWithFilterParameterWhenGetTaxonomiesEndpointIsCalledThenItReturnsOnlyFilteredTaxonomies()
{
// arrange
var vocabularyFP = Randomm.Create <string>();
var taxonomies = EntityHelpers.CreateTaxonomies(5).ToList();
taxonomies[1].Vocabulary = vocabularyFP;
taxonomies[3].Vocabulary = vocabularyFP;
DatabaseContext.Taxonomies.AddRange(taxonomies);
DatabaseContext.SaveChanges();
// act
var requestUri = new Uri($"api/v1/taxonomies?vocabulary={vocabularyFP}", UriKind.Relative);
var response = Client.GetAsync(requestUri).Result;
var content = response.Content;
var stringResponse = await content.ReadAsStringAsync().ConfigureAwait(true);
var deserializedBody = JsonConvert.DeserializeObject <TaxonomyResponseList>(stringResponse);
// assert
response.StatusCode.Should().Be(200);
deserializedBody.Taxonomies.Count.Should().Be(2);
}
private User CreateUser()
{
_user = EntityHelpers.CreateUser();
_userDomain = _usersGateway.AddUser(_mapper.ToDomain(_user));
_user = _mapper.FromDomain(_userDomain);
return(_user);
}
private Organisation CreateOrganisation()
{
_organisation = EntityHelpers.CreateOrganisation();
_organisationDomain = _organisationsGateway.CreateOrganisation(_organisation);
_organisation = _mapper.FromDomain(_organisationDomain);
return(_organisation);
}
public void GivenInvalidOrganisationIdOnCreateExceptionWillBeThrown()
{
_organisation = EntityHelpers.CreateOrganisation();
_organisation.Id = 999999999;
_classUnderTest.Invoking(c => c.LinkUserToOrganisation(_organisation.Id, CreateUser().Id))
.Should()
.Throw <Exception>();
}
private async Task <TableResult> HandleUpsertAsync(TableOperation operation, CloudTableClient client, CloudTable table, TableRequestOptions options, OperationContext context)
{
Document document = EntityHelpers.GetDocumentFromEntity(operation.Entity, context, options);
ResourceResponse <Document> response = await client.DocumentClient.UpsertDocumentAsync(table.GetCollectionUri(), document);
context.RequestResults.Add(response.ToRequestResult());
return(this.GetTableResultFromResponse(operation, response, context, options));
}
public async Task SearchServicesReturnServicesAccordingToRankIfMatched()
{
var searchWord1 = Randomm.Word();
var searchWord2 = Randomm.Word();
var irrelevantWord = Randomm.Word();
var bridgeSyn1Word = Utility.SuperSetOfString(searchWord1);
var bridgeSyn2Word = Utility.SuperSetOfString(searchWord2);
var synWord1 = Randomm.Word();
var synWord2 = Randomm.Word();
var synWord3 = Randomm.Word();
var synonymGroup1 = EntityHelpers.CreateSynonymGroupWithWords();
var synonymGroup2 = EntityHelpers.CreateSynonymGroupWithWords();
var dummySynGroup = EntityHelpers.CreateSynonymGroupWithWords();
var bridgeSynonym1 = EntityHelpers.SynWord(synonymGroup1, bridgeSyn1Word);
var bridgeSynonym2 = EntityHelpers.SynWord(synonymGroup2, bridgeSyn2Word);
var matchSynonym1 = EntityHelpers.SynWord(synonymGroup1, synWord1);
var matchSynonym2 = EntityHelpers.SynWord(synonymGroup1, synWord2);
var matchSynonym3 = EntityHelpers.SynWord(synonymGroup2, synWord3);
synonymGroup1.SynonymWords.Add(bridgeSynonym1);
synonymGroup2.SynonymWords.Add(bridgeSynonym2);
synonymGroup1.SynonymWords.Add(matchSynonym1);
synonymGroup1.SynonymWords.Add(matchSynonym2);
synonymGroup2.SynonymWords.Add(matchSynonym3);
var services = EntityHelpers.CreateServices(5);
var matchService1 = EntityHelpers.CreateService();
var matchService2 = EntityHelpers.CreateService();
var matchService3 = EntityHelpers.CreateService();
var matchService4 = EntityHelpers.CreateService();
matchService1.Name += searchWord2;
//matchService2.Description += synWord2;
matchService2.Description += " " + synWord2; //15 Feb 2021 - Change made so we only search for whole words in the service description! - So we add a space.
matchService3.Organization.Name += synWord3;
matchService4.Organization.Name += searchWord1;
services.AddMany(matchService1, matchService2, matchService3, matchService4);
DatabaseContext.SynonymGroups.AddRange(synonymGroup1);
DatabaseContext.SynonymGroups.AddRange(synonymGroup2);
DatabaseContext.SynonymGroups.AddRange(dummySynGroup);
DatabaseContext.Services.AddRange(services);
DatabaseContext.SaveChanges();
var requestUri = new Uri($"api/v1/services?search={searchWord1} {searchWord2} {irrelevantWord}", UriKind.Relative);
var response = Client.GetAsync(requestUri).Result;
response.StatusCode.Should().Be(200);
var content = response.Content;
var stringContent = await content.ReadAsStringAsync().ConfigureAwait(false);
var deserializedBody = JsonConvert.DeserializeObject <GetServiceResponseList>(stringContent);
deserializedBody.Services.Count.Should().Be(4);
deserializedBody.Services[0].Name.Should().Be(matchService4.Name);
deserializedBody.Services[1].Name.Should().Be(matchService1.Name);
deserializedBody.Services[2].Name.Should().Be(matchService3.Name);
deserializedBody.Services[3].Name.Should().Be(matchService2.Name);
}
public async Task <ActionResult> AssignTechAsync(IssueVM model)
{
try
{
var issue = new IssueRepo().GetById(model.IssueId);
issue.TechnicianId = model.TechnicianId;
issue.IssueState = Models.Enums.IssueStates.Atandı;
issue.OptReport = model.OptReport;
new IssueRepo().Update(issue);
var technician = await NewUserStore().FindByIdAsync(issue.TechnicianId);
TempData["Message"] =
$"{issue.Description} adlı arızaya {technician.Name} {technician.Surname} teknisyeni atandı.";
var customer = NewUserManager().FindById(issue.CustomerId);
var emailService = new EmailService();
var body = $"Merhaba <b>{GetNameSurname(issue.CustomerId)}</b><br>{issue.Description} adlı arızanız onaylanmıştır ve görevli teknisyen en kısa sürede yola çıkacaktır.";
await emailService.SendAsync(new IdentityMessage()
{
Body = body,
Subject = $"{issue.Description} adlı arıza hk."
}, customer.Email);
var issueLog = new IssueLog()
{
IssueId = issue.Id,
Description = "Teknisyene atandı.",
FromWhom = "Operatör"
};
new IssueLogRepo().Insert(issueLog);
return(RedirectToAction("AllIssues", "Operator"));
}
catch (DbEntityValidationException ex)
{
TempData["Message"] = new ErrorVM()
{
Text = $"Bir hata oluştu: {EntityHelpers.ValidationMessage(ex)}",
ActionName = "AssignTechAsync",
ControllerName = "Operator",
ErrorCode = 500
};
return(RedirectToAction("Error500", "Home"));
}
catch (Exception ex)
{
TempData["Message"] = new ErrorVM()
{
Text = $"Bir hata oluştu {ex.Message}",
ActionName = "AssignTechAsync",
ControllerName = "Operator",
ErrorCode = 500
};
return(RedirectToAction("Error500", "Home"));
}
}
public void ImageDeleteActionCallsServicesGateway()
{
var serviceId = Randomm.Id();
var imageId = Randomm.Id();
var file = EntityHelpers.CreateFile();
_mockServicesGateway.Setup(sg => sg.GetFile(It.IsAny <int>())).ReturnsAsync(file);
_classUnderTest.ExecuteDelete(serviceId, imageId);
_mockServicesGateway.Verify(sg => sg.DeleteFileInfo(It.IsAny <int>(), It.IsAny <File>()), Times.Once);
}
public void GetTaxonomiesReturnsTaxonomies() // all
{
var entity = EntityHelpers.CreateTaxonomy();
DatabaseContext.Taxonomies.Add(entity);
DatabaseContext.SaveChanges();
var response = _classUnderTest.GetTaxonomies(null).ToList();
response.First().Name.Should().Be(entity.Name);
}
public void CanGetARoleEntity()
{
var role = EntityHelpers.CreateRole();
DatabaseContext.Add(role);
DatabaseContext.SaveChanges();
var result = DatabaseContext.Roles.FirstOrDefault(x => x.Id == role.Id);
result.Should().BeEquivalentTo(role);
}
public void CanCreateAnAnalyticsEventEntity()
{
var analyticsEvent = EntityHelpers.CreateAnalyticsEvent();
DatabaseContext.Add(analyticsEvent);
DatabaseContext.SaveChanges();
var result = DatabaseContext.ServiceAnalytics.ToList().FirstOrDefault();
result.Should().BeEquivalentTo(analyticsEvent);
}
public void CanGetAUserOrganizationEntity()
{
var userOrganization = EntityHelpers.CreateUserOrganization();
DatabaseContext.Add(userOrganization);
DatabaseContext.SaveChanges();
var result = DatabaseContext.UserOrganizations.ToList().FirstOrDefault();
result.Should().BeEquivalentTo(userOrganization);
}
public void CanGetATaxonomyEntity()
{
var taxonomy = EntityHelpers.CreateTaxonomy();
DatabaseContext.Add(taxonomy);
DatabaseContext.SaveChanges();
var result = DatabaseContext.Taxonomies.ToList().FirstOrDefault();
result.Should().BeEquivalentTo(taxonomy);
}
public void CanGetASynonymGroupEntity()
{
var synonymGroup = EntityHelpers.CreateSynonymGroup();
DatabaseContext.Add(synonymGroup);
DatabaseContext.SaveChanges();
var result = DatabaseContext.SynonymGroups.FirstOrDefault(x => x.Id == synonymGroup.Id);
result.Should().BeEquivalentTo(synonymGroup);
}
public void CanGetAServiceLocationEntity()
{
var serviceLocation = EntityHelpers.CreateServiceLocation();
DatabaseContext.Add(serviceLocation);
DatabaseContext.SaveChanges();
var result = DatabaseContext.ServiceLocations.ToList().FirstOrDefault();
result.Should().BeEquivalentTo(serviceLocation);
}
public void GivenAnIdAMatchingOrganisationGetsDeleted()
{
var organisation = EntityHelpers.CreateOrganisation();
DatabaseContext.Add(organisation);
DatabaseContext.SaveChanges();
_classUnderTest.DeleteOrganisation(organisation.Id);
var expectedResult = DatabaseContext.Organisations.Find(organisation.Id);
expectedResult.Should().BeNull();
}
public void GivenAnIdAMatchingSynonymWordGetsDeleted()
{
var synonymWord = EntityHelpers.CreateSynonymWord();
DatabaseContext.Add(synonymWord);
DatabaseContext.SaveChanges();
_classUnderTest.DeleteSynonymWord(synonymWord.Id);
var expectedResult = DatabaseContext.SynonymWords.Find(synonymWord.Id);
expectedResult.Should().BeNull();
}
public void GivenAnIdAMatchingTaxonomyGetsDeleted()
{
var taxonomy = EntityHelpers.CreateTaxonomy();
DatabaseContext.Add(taxonomy);
DatabaseContext.SaveChanges();
_classUnderTest.DeleteTaxonomy(taxonomy.Id);
var expectedResult = DatabaseContext.Taxonomies.Find(taxonomy.Id);
expectedResult.Should().BeNull();
}
public void GivenValidSessionInDatabaseRefreshSessionUpdatesLastAccessAt()
{
var session = EntityHelpers.CreateSession("VCSO");
DatabaseContext.Sessions.Add(session);
DatabaseContext.SaveChanges();
_classUnderTest.RefreshSessionExpiry(session.Id);
var updatedSession = DatabaseContext.Sessions.Find(session.Id);
updatedSession.LastAccessAt.Should().BeCloseTo(DateTime.Now);
}
public void GivenValidSessionInDatabaseSessionGetsReturned()
{
var session = EntityHelpers.CreateSession("VCSO");
DatabaseContext.Sessions.Add(session);
DatabaseContext.SaveChanges();
var gatewayResult = _classUnderTest.GetSessionByToken(session.Payload);
gatewayResult.Should().NotBeNull();
gatewayResult.Should().BeEquivalentTo(session);
}
public void CanGetASynonymWordEntity()
{
var synonymWord = EntityHelpers.CreateSynonymWord();
DatabaseContext.Add(synonymWord);
DatabaseContext.SaveChanges();
//var result = DatabaseContext.SynonymWords.ToList().FirstOrDefault();
var result = DatabaseContext.SynonymWords.FirstOrDefault(x => x.Id == synonymWord.Id);
result.Should().BeEquivalentTo(synonymWord);
}
public void GivenTaxonomyDomainTaxonomyGetsCreated()
{
var taxonomy = EntityHelpers.CreateTaxonomy();
var gatewayResult = _classUnderTest.CreateTaxonomy(taxonomy);
var expectedResult = DatabaseContext.Taxonomies.Where(x => x.Name == taxonomy.Name).FirstOrDefault();
gatewayResult.Should().NotBeNull();
gatewayResult.Should().BeEquivalentTo(_mapper.ToDomain(expectedResult), options =>
{
return(options);
});
}
public void GivenSynonymWordDomainObjectSynonymWordGetsCreated()
{
var synonymWord = EntityHelpers.CreateSynonymWord();
var gatewayResult = _classUnderTest.CreateSynonymWord(synonymWord);
var expectedResult = DatabaseContext.SynonymWords.Where(x => x.Word == synonymWord.Word).FirstOrDefault();
gatewayResult.Should().NotBeNull();
gatewayResult.Should().BeEquivalentTo(expectedResult, options =>
{
return(options);
});
}
public void GivenSynonymGroupDomainObjectSynonymGroupGetsCreated()
{
var synonymGroup = EntityHelpers.CreateSynonymGroup();
var gatewayResult = _classUnderTest.CreateSynonymGroup(synonymGroup);
var expectedResult = DatabaseContext.SynonymGroups.Where(x => x.Name == synonymGroup.Name).FirstOrDefault();
gatewayResult.Should().NotBeNull();
gatewayResult.Should().BeEquivalentTo(expectedResult, options =>
{
options.Excluding(ex => ex.SynonymWords);
return(options);
});
}
public ActionResult Add(Category model)
{
try
{
if (model.SupCategoryId == 0)
{
model.SupCategoryId = null;
}
if (!ModelState.IsValid)
{
ModelState.AddModelError("CategoryName", "Kategori adı 100 karakteri geçemez");
model.SupCategoryId = model.SupCategoryId ?? 0;
ViewBag.CategoryList = GetCategorySelectList();
return(View(model));
}
if (model.SupCategoryId > 0)
{
model.TaxRate = new CategoryRepo().GetById(model.SupCategoryId).TaxRate;
}
new CategoryRepo().Insert(model);
TempData["Message"] = $"\n{model.CategoryName} isimli kategori başarıyla eklenmiştir";
return(RedirectToAction("Add"));
}
catch (DbEntityValidationException ex)
{
// todo:hata sayfası yap
TempData["Model"] = new ErrorViewModel()
{
Text = $"Bir hata oluştu\n{EntityHelpers.ValidationMessage(ex)}",
ActionName = "Add",
ControllerName = "Category",
ErrorCode = 500
};
return(RedirectToAction("Error", "Home"));
}
catch (Exception ex)
{
// todo:hata sayfası yap
TempData["Model"] = new ErrorViewModel()
{
Text = $"Bir hata oluştu\n{ex.Message}",
ActionName = "Add",
ControllerName = "Category",
ErrorCode = 500
};
return(RedirectToAction("Error", "Home"));
}
}
public ActionResult Add(Category model)
{
try
{
if (model.SupCategoryId == 0)
{
model.SupCategoryId = null;
}
if (!ModelState.IsValid) //veritabanıyla annotation validation işlemini doğrular
{
// ModelState.AddModelError("CategoryName", "100 karakteri geçme");
model.SupCategoryId = model.SupCategoryId ?? 0;
ViewBag.CategoryList = GetCategorySelectList();
return(View(model));
}
if (model.SupCategoryId > 0)
{
model.TaxRate = new CategoryRepo().GetById(model.SupCategoryId).TaxRate;
}
new CategoryRepo().Insert(model);
TempData["Message"] = $"{model.CategoryName} isimli kategori başarıyla eklendi";
return(RedirectToAction("Add"));
}
catch (DbEntityValidationException ex)
{
TempData["Model"] = new ErrorViewModel()
{
Text = $"Bir hata oluştu{EntityHelpers.ValidationMessage(ex)}",
ActionName = "Add",
ControllerName = "Category",
ErrorCode = 500
};
return(RedirectToAction("Error", "Home"));
}
catch (Exception ex)
{
TempData["Model"] = new ErrorViewModel()
{
Text = $"Bir hata oluştu{ex.Message}",
ActionName = "Add",
ControllerName = "Category",
ErrorCode = 500
};
return(RedirectToAction("Error", "Home"));
}
}
public void FactoryShouldProvidePlaceholderImageIfImagePropertyIsNull()
{
// arrange
var domainService = EntityHelpers.CreateService().ToDomain();
domainService.Image = null;
// act
var expectedService = domainService.ToResponseService();
// assert
expectedService.Images.Should().NotBeNull();
expectedService.Images.Medium.Should().Be(_imagePlaceholder);
expectedService.Images.Original.Should().Be(_imagePlaceholder);
}
public void GivenOrganisationDomainObjectOrganisationGetsCreated()
{
var organisation = EntityHelpers.CreateOrganisation();
var gatewayResult = _classUnderTest.CreateOrganisation(organisation);
var expectedResult = DatabaseContext.Organisations.Where(x => x.Name == organisation.Name).FirstOrDefault();
gatewayResult.Should().NotBeNull();
gatewayResult.Should().BeEquivalentTo(expectedResult, options =>
{
options.Excluding(ex => ex.ReviewerU);
options.Excluding(ex => ex.Services);
options.Excluding(ex => ex.UserOrganisations);
return(options);
});
}
public void GivenAnIdAMatchingSynonymWordGetsReturned()
{
var synonymWord = EntityHelpers.CreateSynonymWord();
DatabaseContext.Add(synonymWord);
DatabaseContext.SaveChanges();
var gatewayResult = _classUnderTest.GetSynonymWord(synonymWord.Id);
var expectedResult = DatabaseContext.SynonymWords.Find(synonymWord.Id);
gatewayResult.Should().NotBeNull();
gatewayResult.Should().BeEquivalentTo(expectedResult, options =>
{
return(options);
});
}
