public async Task <EntityOperationResult <TBase> > CreateItemAsync(TDto basketCreateDto)
{
string errors = CheckAndGetErrors(basketCreateDto);
if (!string.IsNullOrEmpty(errors))
{
return(EntityOperationResult <TBase> .Failure().AddError(errors));
}
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
try
{
TBase value = _mapper.Map <TBase>(basketCreateDto);
var entity = await unitOfWork.GetRepository <TBase>().AddAsync(value);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <TBase> .Success(entity));
}
catch (Exception ex)
{
return(EntityOperationResult <TBase> .Failure().AddError(ex.Message));
}
}
}
public List <UserDto> UserList(ProjectDto projectDto)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
var userList = unitOfWork.User.UserList();
return(GetUserInProjectAndAll(userList, null, false));
}
}
/// <summary>
/// Анализ данных (что нужно добавить и что нет)
/// </summary>
private void AnalizeDate()
{
if (_languageDtos.Count != _countChackLanguage)
{
return;
}
if (_languageDtos == null || _languageDtos.Count == 0 || _languageDtos.Count != 2)
{
_progressBar.SendProgress(_countMultiAddToDateBase, _countMultiAddToDateBase, _titleOfAnalizeDateOperation);
return;
}
List <Language> languages = new List <Language>();
List <Word> words = new List <Word>();
List <WordTranslation> wordTranslations = new List <WordTranslation>();
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
List <string> names = _languageDtos.Select(x => x.Name.Trim()).ToList();
languages = unitOfWork.Language.GetLanguageListOfName(names);
names = _wordDtos.Select(x => x.Name.Trim()).ToList();
if (languages.Count > 0)
{
int idFromLanguage = languages[0].Id;
int idToLanguage = languages.Count > 1 ? languages[1].Id : -1;
words = unitOfWork.Word.GetWordsForTwoLanguage(names, idFromLanguage, idToLanguage);
List <int> wordIdList = words.Select(x => x.Id).ToList();
if (wordIdList?.Count > 0)
{
wordTranslations = unitOfWork.WordTranslation.GetLanguageListOfName(wordIdList, idFromLanguage, idToLanguage);
}
}
}
int iteration = 0;
_countMultiAddToDateBase = languages.Count + _wordDtos.Count + words.Count + _wordTranslationDtos.Count + wordTranslations.Count;
iteration = AnalizeLanguage(iteration, languages);
iteration = AnalizeWord(iteration, words);
iteration = AnalizeWordTranslations(iteration, wordTranslations);
}
public async Task <EntityOperationResult <Dish> > CreateItemAsync(DishCreateDto createDto, string path)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
if (unitOfWork.Dish.IsExistByNAme(createDto.Name, createDto.OrganizationId))
{
return(EntityOperationResult <Dish>
.Failure()
.AddError($"Блюдо с именем {createDto.Name} уже существует"));
}
if (createDto.Price <= 0)
{
return(EntityOperationResult <Dish>
.Failure()
.AddError("Цена не может быть меньше или равняться нулю"));
}
try
{
var dish = new Dish
{
Name = createDto.Name,
OrganizationId = createDto.OrganizationId,
Price = createDto.Price,
PictureName = System.Guid.NewGuid().ToString(),
Comment = createDto.Comment
};
var fileService = new FileService(createDto.File, path + "\\" +
dish.PictureName, createDto.PictureName);
dish.PictureFormat = fileService.GetTypeFile();
var entity = await unitOfWork.Dish.AddAsync(dish);
await unitOfWork.CompleteAsync();
fileService.Add();
return(EntityOperationResult <Dish> .Success(entity));
}
catch (Exception ex)
{
return(EntityOperationResult <Dish> .Failure().AddError(ex.Message));
}
}
}
public async Task <EntityOperationResult <TBase> > CreateItemAsync(TDto basketCreateDto)
{
// Валидацию модели можно сделать через атрибуты валидации, которые ты вешаешь на свойства класса.
// Взывать проверку на основе атрибутов можно своим кодом. Я уже такой писал:
// https://github.com/maximgorbatyuk/net-blank-app/blob/master/src/Utils/Validators/EntityValidator.cs
string errors = CheckAndGetErrors(basketCreateDto);
if (!string.IsNullOrEmpty(errors))
{
return(EntityOperationResult <TBase> .Failure().AddError(errors));
}
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
try
{
TBase value = _mapper.Map <TBase>(basketCreateDto);
var entity = await unitOfWork.GetRepository <TBase>().AddAsync(value);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <TBase> .Success(entity));
}
catch (Exception ex)
{
// Если ты хочешь использовать подход с классом-прокси EntityOperationResult,
// То я бы сохранял и передавал выше еще и сам объект ex, потому что в эксепшене важно не только месседж,
// но и стектрейс, и дополнительная инфа, и тип класса исключения.
// Но я бы отказался от такого прокси-класса и пробрасывал бы исключение наверх дальше, даже
// не отлавливая его здесь.
// Исключения ты отлавливаешь в одной точке - в созданной специально для этого middleware.
// а узнать, что это такое, ты можешь либо из нашего курса, либо на сайте metanit.com
return(EntityOperationResult <TBase> .Failure().AddError(ex.Message));
}
}
}
public async Task <EntityOperationResult <Basket> > CreateOrEditItemAsync(BasketEditDto basketEditDto)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
var basket = unitOfWork.Basket.GetOpen(basketEditDto.UserId, basketEditDto.OrganizationId);
if (basket == null)
{
var createDto = new BasketCreateDto
{
UserId = basketEditDto.UserId,
OrganizationId = basketEditDto.OrganizationId
};
foreach (var rec in basketEditDto.BasketInventoryDtos)
{
var basketInventory = new BasketInventoryCreateDto
{
DishId = rec.DishId,
CountInventory = rec.CountInventory,
Price = rec.Price
};
createDto.BasketInventoryDto.Add(basketInventory);
}
return(await CreateItemAsync(createDto));
}
else
{
return(await EditItemAsync(basketEditDto));
}
}
}
public async Task <EntityOperationResult <ProjectTask> > CreateItemAsync(ProjectTaskDto projectTaskCreateDto)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
var result = Check(projectTaskCreateDto);
if (result != null)
{
return(result);
}
if (projectTaskCreateDto.Project == null)
{
return(EntityOperationResult <ProjectTask>
.Failure()
.AddError("Не указан Проект"));
}
try
{
var project = new ProjectTask
{
Name = projectTaskCreateDto.Name,
AuthorId = projectTaskCreateDto.Author.Id,
ExecutorId = projectTaskCreateDto.Executor.Id,
Status = (int)projectTaskCreateDto.Status,
ProjectId = projectTaskCreateDto.Project.Id,
Priority = projectTaskCreateDto.Priority,
Comment = projectTaskCreateDto.Comment
};
var entity = await unitOfWork.ProjectTask.AddAsync(project);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <ProjectTask> .Success(entity));
}
catch (Exception ex)
{
return(EntityOperationResult <ProjectTask> .Failure().AddError(ex.Message));
}
}
}
public async Task <EntityOperationResult <Organization> > CreateItemAsync(OrganizationCreateDto createDto, string path)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
if (unitOfWork.Organization.IsExistByNAme(createDto.Name))
{
return(EntityOperationResult <Organization>
.Failure()
.AddError($"Кафе с именем {createDto.Name} уже существует"));
}
try
{
var organization = new Organization
{
Name = createDto.Name,
PictureName = System.Guid.NewGuid().ToString(),
Comment = createDto.Comment,
};
var fileService = new FileService(createDto.File, path + "\\" +
organization.PictureName, createDto.PictureName);
organization.PictureFormat = fileService.GetTypeFile();
var entity = await unitOfWork.Organization.AddAsync(organization);
await unitOfWork.CompleteAsync();
fileService.Add();
return(EntityOperationResult <Organization> .Success(organization));
}
catch (Exception ex)
{
return(EntityOperationResult <Organization> .Failure().AddError(ex.Message));
}
}
}
public async Task <EntityOperationResult <Project> > CreateItemAsync(ProjectDto projectCreateDto)
{
using (var unitOfWork = _unitOfWorkFactory.MakeUnitOfWork())
{
var result = Check(projectCreateDto);
if (result != null)
{
return(result);
}
if (projectCreateDto.ProjectUsers == null || projectCreateDto.ProjectUsers.Count == 0)
{
return(EntityOperationResult <Project>
.Failure()
.AddError("Не указаны исполнители"));
}
try
{
var project = new Project();
GetProjectDtoToProject(projectCreateDto, project);
var entity = await unitOfWork.Project.AddAsync(project);
await unitOfWork.CompleteAsync();
var projectUserList = Mapper.Map <List <ProjectUser> >(projectCreateDto.ProjectUsers
.Where(x => x.Status == ProjectUserStatus.New)
.ToList());
SetProjectIdToList(projectUserList, entity.Id);
unitOfWork.Project.UpdateProjectUsers(projectUserList);
await unitOfWork.CompleteAsync();
return(EntityOperationResult <Project> .Success(entity));
}
catch (Exception ex)
{
return(EntityOperationResult <Project> .Failure().AddError(ex.Message));
}
}
}