public async void SearchTestAsync()
{
// Arrange
using (var context = new VotingContext(new SqliteProvider().GetDbContextOptions()))
{
var repository = new Repository <Candidate>(context);
// Act
await repository.AddAsync(new Candidate()
{
Id = 1,
Name = "Ripal Barot"
});
await repository.AddAsync(new Candidate()
{
Id = 2,
Name = "Falguni Barot"
});
await repository.AddAsync(new Candidate()
{
Id = 3,
Name = "Neil Barot"
});
var candidateList = await repository.SearchAsync(candidate => candidate.Name.Contains("Barot"));
// Assert
Assert.Equal(3, candidateList.Count());
}
}
public async void GetByIdTestAsync()
{
// Arrange
using (var context = new VotingContext(new SqliteProvider().GetDbContextOptions()))
{
var repository = new Repository <Candidate>(context);
// Act
await repository.AddAsync(new Candidate()
{
Id = 1,
Name = "Ripal Barot"
});
await repository.AddAsync(new Candidate()
{
Id = 2,
Name = "Falguni Barot"
});
await repository.AddAsync(new Candidate()
{
Id = 3,
Name = "Neil Barot"
});
// Assert
var candidate = await repository.GetByIdAsync(2);
Assert.Equal("Falguni Barot", candidate.Name);
}
}
public async void CreateTestAsync()
{
// Arrange
using (var context = new VotingContext(new SqliteProvider().GetDbContextOptions()))
{
var saver = new Repository <Candidate>(context);
// Act
await saver.AddAsync(new Candidate()
{
Name = "Ripal Barot"
});
await saver.AddAsync(new Candidate()
{
Name = "Falguni Barot"
});
await saver.AddAsync(new Candidate()
{
Name = "Neil Barot"
});
// Assert
Assert.Equal(3, context.Candidates.Count());
Assert.Equal("Neil Barot",
context.Candidates.Where(c => c.Name == "Neil Barot").Select(c => c.Name).FirstOrDefault());
}
}
public async Task AddAsync_ShouldAddDepartment()
{
var department = new Department {
InstructorID = 1, Name = "Physics", Budget = 0
};
await _sut.AddAsync(department);
await _sut.SaveChangesAsync();
var departmentAdded = _sut.GetAll().Last();
Assert.Equal(department.Name, departmentAdded.Name);
}
public async Task UpdateProjectType()
{
var projectTypeId = SanitizeName(nameof(UpdateProjectType));
var projectType = await Repository.AddAsync(new ProjectTypeDocument
{
Id = projectTypeId,
Region = "EastUS",
Providers = GetProviderReferences().ToList()
}).ConfigureAwait(false);
Assert.Equal(projectTypeId, projectType.Id);
AssertContainerDocumentMetadata(projectType);
projectType.Subscriptions.Add(Guid.NewGuid());
var projectType2 = await Repository
.SetAsync(projectType)
.ConfigureAwait(false);
Assert.Equal(projectTypeId, projectType2.Id);
AssertContainerDocumentMetadata(projectType2);
Assert.Equal(projectType.Subscriptions.First(), projectType2.Subscriptions.First());
}
async Task AddToRepository(string relativePath, string contents, bool toVcs, bool commit)
{
var monitor = new ProgressMonitor();
string added = Path.Combine(LocalPath, relativePath);
if (contents == null)
{
Directory.CreateDirectory(added);
}
else
{
File.WriteAllText(added, contents);
}
if (toVcs)
{
await Repo.AddAsync(new FilePath [] { added }, false, monitor);
}
if (commit)
{
await CommitFileAsync(added);
}
else
{
AddedItems.Add(added);
}
}
public async Task CantModifyUserOnInterceptionsWhenDisabledByTypeAsync()
{
const string user = "******";
var entity = new CustomerWithTimeStamp();
var options = new RepositoryOptionsBuilder()
.UseInMemoryDatabase()
.UseInterceptor(new TestRepositoryTimeStampInterceptor(user))
.Options;
var repo = new Repository <CustomerWithTimeStamp>(options)
{
InterceptorsEnabled = true
};
repo.InterceptorTypesDisabled.Add(typeof(TestRepositoryTimeStampInterceptor), true);
Assert.Null(entity.CreateTime);
Assert.Null(entity.ModTime);
Assert.Null(entity.CreateUser);
Assert.Null(entity.ModUser);
await repo.AddAsync(entity);
Assert.Null(entity.CreateTime);
Assert.Null(entity.ModTime);
Assert.Null(entity.CreateUser);
Assert.Null(entity.ModUser);
}
public async Task <EditorDocument> Create(DocumentCreateOrUpdateInput input)
{
var itemToInsert = Mapper.Map <EditorDocument>(input);
if (string.IsNullOrEmpty(itemToInsert.Title))
{
itemToInsert.Title = await GenerateDocumentTitle();
}
else
{
var hasSameTitleDocument = await HasSameTitleDocument(itemToInsert.Title);
if (hasSameTitleDocument)
{
Response.StatusCode = (int)HttpStatusCode.Conflict;
return(null);
}
}
itemToInsert.UserId = JwtReader.GetUserId();
itemToInsert.DocumentAccess ??= EditorDocumentAllowedAccess.Private;
var item = await Repository.AddAsync(itemToInsert);
await Context.SaveChangesAsync();
return(item.Entity);
}
public async Task GetAsync_TestAsync()
{
//Arrange
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, _logger);
var expected = new DataModels.Contract
{
Id = 1,
ContractNumber = "Test",
ContractVersion = 1,
Year = "2021"
};
//Act
await repo.AddAsync(expected);
await work.CommitAsync();
var actual = await contractRepo.GetAsync(expected.Id);
//Assert
actual.Should().Be(expected);
}
public async Task GetByContractNumberAsync_TestAsync()
{
//Arrange
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, _logger);
const string ContractNumber = "Test";
var expected = new List <DataModels.Contract>
{
new DataModels.Contract {
Id = 1, ContractNumber = ContractNumber, ContractVersion = 1
},
new DataModels.Contract {
Id = 2, ContractNumber = ContractNumber, ContractVersion = 2
},
new DataModels.Contract {
Id = 3, ContractNumber = ContractNumber, ContractVersion = 3
},
};
foreach (var item in expected)
{
await repo.AddAsync(item);
}
await work.CommitAsync();
//Act
var actual = await contractRepo.GetByContractNumberAsync(ContractNumber);
//Assert
actual.Should().BeEquivalentTo(expected);
}
/// <summary>
/// Добавить или отредактировать
/// </summary>
protected async Task AddAsync()
{
//Получаем дату платежа в текстовом виде, как предусматривает модель
var date = paymentViewModel.DatePayment.ToString("dd.MM.yyyy");
//Проверяем есть ли активная модель
if (payment == null && Invoice != null)
{
//Создаем экземпляр модели
payment = new Payment()
{
DatePayment = date,
IdInvoice = Invoice.IdInvoice,
PaymentSum = paymentViewModel.PaymentSum,
Paid = paymentViewModel.Paid,
};
//Добавляем модель в БД
await Repository.AddAsync(payment);
}
else
{
//Обновляем модель и записываем изменения в БД
payment.DatePayment = date;
payment.Paid = paymentViewModel.Paid;
payment.PaymentSum = paymentViewModel.PaymentSum;
await Repository.EditAsync(payment);
}
//Меняем поле оплаты в квитанции и записываем в БД
Invoice.Pay = payment.Paid;
await InvoiceRepository.EditAsync(Invoice);
CloseModal();
await StateUpdate();
}
public async Task CreateAsync(CreateBrandBindingModel model)
{
Brand brand = this.Mapper.Map <Brand>(model);
await Repository.AddAsync(brand);
await Repository.SaveChangesAsync();
}
public virtual async Task <ActionResult <TViewModel> > Put([FromBody] TInsertModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
TModel item;
if (model.Id == null || model.Id.Equals(0))
{
item = ObjectMapper.MapTo <TModel>(model);
await Repository.AddAsync(item);
}
else
{
item = await Repository.GetAsync(model.Id);
if (item == null)
{
ModelState.AddModelError("", "item-not-found");
return(BadRequest(ModelState));
}
item = ObjectMapper.MapTo(model, item);
Repository.Update(item);
}
await Repository.SaveAsync();
return(ObjectMapper.MapTo <TViewModel>(item));
}
/// <summary>
/// 更新实体。
/// </summary>
/// <param name="sourceEntity">源实体。</param>
/// <returns></returns>
public virtual async Task <bool> UpdateEntity(TEntity sourceEntity)
{
var addAction = false;
var targetEntity = await Repository.SingleByIdAsync(sourceEntity.Id);
if (targetEntity == null)
{
targetEntity = Repository.Create();
addAction = true;
}
var editPropertyMetadata = EntityControllerDescriptor.EntityMetadata.EditPropertyMetadatas;
foreach (var metadata in editPropertyMetadata)
{
await UpdateProperty(targetEntity, sourceEntity, metadata);
}
if (addAction)
{
await Repository.AddAsync(sourceEntity);
}
else
{
await Repository.EditAsync(targetEntity);
}
return(true);
}
public async Task AddAsync(GrupoIndexDTO grupoDTO)
{
Grupo grupo = grupoDTO.BuildModel();
await _repository.AddAsync(grupo);
await _repository.SaveChangesAsync();
}
public async Task SendContactForm(ContactFormInput input)
{
var entity = Mapper.Map <Domain.Entities.ContactForm.ContactForm>(input);
await Repository.AddAsync(entity);
await Context.SaveChangesAsync();
}
public async Task <FormaPago> GuardarCambios(Guid IdUsuario)
{
try
{
FormaPago model = new FormaPago
{
IdFormaPago = this.IdFormaPago,
Nombre = this.Nombre.Trim(),
Descripcion = this.Descripcion.Trim(),
IdUsuario = this.IdUsuarioL,
Resultado = -2
};
if (State == EntityState.Create)
{
return(await Repository.AddAsync(model, IdUsuario));
}
else if (State == EntityState.Update)
{
return(await Repository.UpdateAsync(model, IdUsuario));
}
return(model);
}
catch (Exception ex)
{
throw ex;
}
}
static async Task Main(string[] args)
{
var coachesList = new HashSet <List <CoacheDto> >();
var tasks = new List <Task <IRestResponse> >();
var restResponse = await Task.WhenAny(TeamEndpoint.GetAllByYear()).Result;
var teamsList = new JsonDeserializer().Deserialize <List <TeamDto> >(restResponse);
foreach (var team in teamsList)
{
tasks.Add(CoachEndpoint.GetCoacheByTeam($"{team.School}"));
}
var coachResponse = await Task.WhenAll(tasks);
foreach (var response in coachResponse)
{
var coache = new JsonDeserializer().Deserialize <List <CoacheDto> >(response);
coachesList.Add(coache);
}
var mapping = new MappingProfile();
var result = mapping.Map(coachesList, teamsList);
var repo = new Repository();
await repo.AddAsync(result);
}
public async Task UpdateLastEmailReminderSentAndLastUpdatedAtAsync_Test()
{
//Arrange
var inMemPdsDbContext = HelperExtensions.GetInMemoryPdsDbContext();
var repo = new Repository <DataModels.Contract>(inMemPdsDbContext);
var work = new SingleUnitOfWorkForRepositories(inMemPdsDbContext);
var contractRepo = new ContractRepository(repo, work, _logger);
int contractId = 1;
const string contractNumber = "main-0001";
const string title = "Test Title";
DateTime lastEmailReminderSent = DateTime.UtcNow;
var working = new List <DataModels.Contract>
{
new DataModels.Contract {
Id = contractId, Title = title, ContractNumber = contractNumber, ContractVersion = 1, Ukprn = 12345678, LastEmailReminderSent = null, LastUpdatedAt = lastEmailReminderSent
}
};
foreach (var item in working)
{
await repo.AddAsync(item);
}
await work.CommitAsync();
await contractRepo.UpdateLastEmailReminderSentAndLastUpdatedAtAsync(contractId);
//Act
var actual = await contractRepo.GetAsync(contractId);
//Assert
actual.LastEmailReminderSent.Should().NotBeNull();
}
public async Task UpdateProject()
{
var project = await Repository.AddAsync(new ProjectDocument()
{
Name = Guid.NewGuid().ToString(),
Type = new ProjectTypeDocument()
{
Id = Guid.NewGuid().ToString()
},
Users = GetUsers().ToList()
}).ConfigureAwait(false);
AssertContainerDocumentMetadata(project);
foreach (var user in GetUsers())
{
project.Users.Add(user);
}
var project2 = await Repository
.SetAsync(project)
.ConfigureAwait(false);
Assert.Equal(project.Id, project2.Id);
AssertContainerDocumentMetadata(project2);
}
public async Task UpdateProvider()
{
var providerId = SanitizeName(nameof(UpdateProvider));
var provider = await Repository.AddAsync(new ProviderDocument()
{
Id = providerId,
Url = "https://www.foo.com",
AuthCode = "3iexLbySHolb0Tsm5PErwg=="
}).ConfigureAwait(false);
Assert.Equal(providerId, provider.Id);
AssertContainerDocumentMetadata(provider);
var registered = DateTime.UtcNow;
provider.Registered = registered;
var provider2 = await Repository
.SetAsync(provider)
.ConfigureAwait(false);
Assert.Equal(providerId, provider2.Id);
AssertContainerDocumentMetadata(provider2);
Assert.Equal(provider.Registered, provider2.Registered);
}
public override async Task <ActionResult> Create([FromBody] Ingredient model)
{
try
{
var entity = Mapper.Map <IngredientModel>(model);
entity.IngredientType = await CategoryRepo.UpsertByNameAsync(model.IngredientType, CategoryType.Ingredient);
entity.PackageType = await CategoryRepo.UpsertByNameAsync(model.PackageType, CategoryType.Package);
await Repository.AddAsync(entity);
await Repository.CommitAsync();
model = Mapper.Map <Ingredient>(entity);
return(Created(this.Url.Action(nameof(GetById), new { id = entity.Id }), model));
}
catch (Exception ex)
{
var methodInfo = MethodBase.GetCurrentMethod();
logger.LogError(ex, $"An Exception occured in {methodInfo.DeclaringType.Name}.{methodInfo.Name}");
await Repository.RevertAsync();
var errorobj = new { Error = ex.GetType().Name, ex.Message };
return(StatusCode(StatusCodes.Status500InternalServerError, errorobj));
}
}
public override async Task <ActionResult <TeacherPartialDto> > Create(TeacherEditDto model)
{
var item = model.MapTo <Teacher>();
var userResult = await _userGrpcService.CreateAsync(new CreateUserDto
{
Firstname = model.Firstname,
LastName = model.LastName,
NationalCode = model.NationalCode
});
item.UserId = userResult.Id;
item.FullName = $"{userResult.Firstname} {userResult.LastName}";
try
{
await Repository.AddAsync(item, new CancellationToken());
}
catch (Exception e)
{
await _userGrpcService.RemoveAsync(userResult.Id);
throw;
}
ActionResult <TeacherPartialDto> actionResult = CreatedAtAction("Get", new
{
id = item.Id
}, item);
return(actionResult);
}
public override async Task ExecuteAsync(Message message, TelegramBotClient client)
{
try
{
var repository = new Repository <Models.User>(
Environment.GetEnvironmentVariable("GRISHA_BOT_FIREBASE_AUTH"),
Environment.GetEnvironmentVariable("GRISHA_BOT_FIREBASE_URL"));
var user = new Models.User()
{
ChatId = message.Chat.Id.ToString(),
UserId = message.From.Id.ToString(),
DateTime = message.Date,
UserName = message.From.Username ?? message.From.FirstName + message.From.LastName
};
await repository.AddAsync(user);
var allUsers = await repository.GetAllAsync().ConfigureAwait(false);
await client.SendTextMessageAsync(
message.Chat.Id,
string.Join(", ", allUsers.Select(x => x.UserName)));
}
catch (Exception ex)
{
await client.SendTextMessageAsync(message.Chat.Id, ex.ToString());
}
}
// Tests Repository.Update.
public virtual async Task UpdateIsDone()
{
var monitor = new ProgressMonitor();
await AddFileAsync("testfile", null, true, true);
await PostCommit(Repo);
// Checkout a second repository.
FilePath second = new FilePath(FileService.CreateTempDirectory() + Path.DirectorySeparatorChar);
await CheckoutAsync(second, RemoteUrl);
Repo2 = GetRepo(second, RemoteUrl);
ModifyPath(Repo2, ref second);
string added = second + "testfile2";
File.Create(added).Close();
await Repo2.AddAsync(new FilePath [] { added }, false, monitor);
ChangeSet changes = Repo2.CreateChangeSet(Repo2.RootPath);
changes.AddFile(await Repo2.GetVersionInfoAsync(added, VersionInfoQueryFlags.IgnoreCache));
changes.GlobalComment = "test2";
await Repo2.CommitAsync(changes, monitor);
await PostCommit(Repo2);
await Task.Run(async() => await Repo.UpdateAsync(Repo.RootPath, true, monitor));
Assert.True(File.Exists(LocalPath + "testfile2"));
Repo2.Dispose();
DeleteDirectory(second);
}
public async Task <Usuario> GuardarCambios(Guid IdUsuario)
{
try
{
Usuario model = new Usuario
{
IdCuentaUsuario = IdCuentaUsuario,
Cuenta = Cuenta,
PasswordHash = Password,
DatosRol = { IdRol = IdRol },
DatosEmpleado = { IdEmpleado = IdEmpleado },
Nombre = this.Nombre,
};
if (State == EntityState.Create)
{
return(await Repository.AddAsync(model, IdUsuario));
}
else if (State == EntityState.Update)
{
return(await Repository.UpdateAsync(model, IdUsuario));
}
return(model);
}
catch (Exception ex)
{
throw ex;
}
}
public override async Task <FeedViewModel> AddAsync <TCreateRequest>(TCreateRequest createRequest)
{
if (!(createRequest is CreateFeedRequest request))
{
var message = GetImproperRequestErrorMessage(typeof(TCreateRequest), nameof(IFeedService));
throw new ArgumentException(message);
}
var entity = createRequest.CreateEntity();
var createdEntity = await Repository.AddAsync(entity);
await Repository.SaveChangesAsync();
var tempEntity = await Repository.GetFeedWithAfflictionsById(createdEntity.Id);
createdEntity.DogAfflictions = tempEntity.DogAfflictions;
var viewModel = new FeedViewModel();
viewModel.Construct(createdEntity);
await _imageService.AddImagesAsync(request.Photos, viewModel.UniqueId);
viewModel.PhotosIds = await _imageService.GetImagesIdsByOwnerGuidAsync(
viewModel.UniqueId,
CancellationToken.None);
return(viewModel);
}
public async Task <CambioVenta> GuardarCambios(Guid IdUsuario, int IdSucursal, Guid IdEmpleado, int IdTurnoEmpleado)
{
try
{
CambioVenta model = new CambioVenta
{
IdSucursal = IdSucursal,
IdEmpleado = IdEmpleado,
IdTurnoEmpleado = IdTurnoEmpleado,
CambioTurno = CambioTurno
};
if (State == EntityState.Create)
{
return(await Repository.AddAsync(model, IdUsuario));
}
else if (State == EntityState.Update)
{
return(await Repository.UpdateCambioWithIdSucursalAsync(model, IdSucursal, IdEmpleado, IdTurnoEmpleado));
}
return(model);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <Proveedor> GuardarCambios(Guid IdUsuario)
{
try
{
Proveedor model = new Proveedor
{
IdProveedor = IdProveedor,
Clave = Clave,
NombreComercial = NombreComercial,
RazonSocial = RazonSocial,
Representante = Representante,
RFC = RFC,
Direccion = Direccion,
Telefono = Telefono,
CorreoElectronico = CorreoElectronico,
CodigoPostal = CodigoPostal,
IdPais = IdPais,
IdEstado = IdEstado,
IdMunicipio = IdMunicipio
};
if (State == EntityState.Create)
{
return(await Repository.AddAsync(model, IdUsuario));
}
else if (State == EntityState.Update)
{
return(await Repository.UpdateAsync(model, IdUsuario));
}
return(model);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Добавить или отредактировать
/// </summary>
protected async Task AddAsync()
{
//Получаем id услуги
int idService = int.Parse(ProviderServiceModel.IdService);
//Проверяем, существует ли текущая модель
if (providersServices == null)
{
//Создаем и инициализируем модель
providersServices = new ProvidersServices()
{
IdProvider = Provider.IdProvider,
IdService = idService
};
//Записываем модель в БД
await Repository.AddAsync(providersServices);
}
else
{
//Меняем модель и записываем изменения в БД
providersServices.IdService = idService;
await Repository.EditAsync(providersServices);
}
CloseModal();
await StateUpdate();
}
