public async Task <ServiceResult <PaginatedListResult <ProductsResponseViewModel> > > Search(ProductsRequestViewModel viewModel)
{
var paginatedListWithModel = await _repository.Search(viewModel);
// Mapping
List <ProductsResponseViewModel> Mapping(List <Product> list)
{
return(list?
.Select(model => new ProductsResponseViewModel
{
Id = model.Id,
ProductName = model.Name,
Code = model.Code,
EanCode = model.EanCode,
SellPriceBruto = model.Price,
Type = model.ProductType,
ProductGroup = model.ProductCategory?.Name
})
.ToList());
}
var paginatedListWithViewModel = paginatedListWithModel.Copy(Mapping);
return(ServiceResultFactory.Success(paginatedListWithViewModel));
}
public async Task <ServiceResult <PaginatedListResult <CompaniesResponseViewModel> > > Search(CompaniesRequestViewModel viewModel)
{
var paginatedListWithModel = await _repository.Search(viewModel);
// Mapping
List <CompaniesResponseViewModel> Mapping(List <Company> list)
{
return(list?
.Select(model => new CompaniesResponseViewModel
{
Id = model.Id,
CompanyName = model.Name,
ClientCode = model.ClientCode,
ContactPerson = model.ContactPerson,
ContactPhone = model.ContactPhone,
ContactEmail = model.ContactEmail,
InvoiceFrequency = model.InvoiceFrequency,
InvoiceEmail = model.InvoiceEmail,
LastLoginTime = model.LastInfoUpdateDate, // ?
IsActive = model.IsActive
})
.ToList());
}
var paginatedListWithViewModel = paginatedListWithModel.Copy(Mapping);
return(ServiceResultFactory.Success(paginatedListWithViewModel));
}
/// <summary>
/// Those are temtcash customer's clients
/// </summary>
/// <param name="customerId"></param>
/// <param name="viewModel"></param>
/// <returns></returns>
public async Task <ServiceResult <PaginatedListResult <CustomersResponseViewModel> > > Search(int customerId, CustomersRequestViewModel viewModel)
{
throw new NotImplementedException();
var paginatedListWithModel = await _repository.Search(viewModel);
// Mapping
List <CustomersResponseViewModel> Mapping(List <Customer> list)
{
return(list?
.Select(model => new CustomersResponseViewModel
{
Id = model.Id,
UsernameOrEmail = model.Email,
Name = model.Name,
//Role = model.Role TODO
CompanysMainUser = model.IsCompany, // TODO? is this correct?
//IsActive = model.IsActive // TODO
//LastLoginTime = model.LastLoginTime // TODO
})
.ToList());
}
var paginatedListWithViewModel = paginatedListWithModel.Copy(Mapping);
return(ServiceResultFactory.Success(paginatedListWithViewModel));
}
public async Task <ServiceResult <PaginatedListResult <SuppliersResponseViewModel> > > Search(SuppliersRequestViewModel viewModel)
{
var paginatedListWithModel = await _repository.Search(viewModel);
// Mapping
List <SuppliersResponseViewModel> Mapping(List <Supplier> list)
{
return(list?
.Select(model => new SuppliersResponseViewModel
{
Id = model.Id,
CompanyName = model.Company?.Name,
//ClientCode = model. // TODO
//ContactPerson = model. //TODO
//ContactPhone = model. //TODO
//ContactEmail = model. //TODO
//InvoiceFrequency = model.InvoiceFrequency // TODO
//InvoiceEmail = model.InvoiceEmail // TODO
//LastLoginTime = model.LastLoginTime // TODO
//IsActive = model.IsActive // TODO
})
.ToList());
}
var paginatedListWithViewModel = paginatedListWithModel.Copy(Mapping);
return(ServiceResultFactory.Success(paginatedListWithViewModel));
}
public async Task <ServiceResult <ProductRequestViewModel> > GetSingle(int id)
{
var model = await _repository.GetSingleAsync(id);
if (model == null)
{
return(ServiceResultFactory.Success <ProductRequestViewModel>(null));
}
var viewModel = new ProductRequestViewModel
{
ProductName = model.Name,
Code = model.Code,
EanCode = model.EanCode,
ProductGroupId = model.ProductCategoryId,
Description = model.Description,
SellingPriceBruto = model.Price,
VatPercent = model.Vat,
Type = model.ProductType,
Unit = model.Unit,
UseProductVat = model.UseProductVat
};
return(ServiceResultFactory.Success(viewModel));
}
public async Task <ServiceResult <PaginatedListResult <InvoicesResponseViewModel> > > Search(InvoicesRequestViewModel viewModel)
{
var paginatedListWithModel = await _repository.Search(viewModel);
// Mapping
List <InvoicesResponseViewModel> Mapping(List <Invoice> list)
{
return(list?
.Select(model => new InvoicesResponseViewModel
{
Id = model.Id,
Number = model.Number,
Date = model.Date,
SumWithoutKm = model.NetoSum,
SumKm = model.VatSum,
SumBruto = model.BrutoSum,
Client = model.Customer?.Name,
//PaymentMethod = model
Seller = model.SellerName
})
.ToList());
}
var paginatedListWithViewModel = paginatedListWithModel.Copy(Mapping);
return(ServiceResultFactory.Success(paginatedListWithViewModel));
}
public async Task <ServiceResult <int> > Create(int companyId, CompanyLicenceCreateOrUpdateRequestViewModel viewModel)
{
var model = new CompanyLicence();
MapViewModelToModel(viewModel, model);
model.CompanyId = companyId;
var validator = new CompanyLicenceCreateOrUpdateRequestViewModelValidator();
var validationResult = await validator.ValidateAsync(model);
if (!validationResult.IsValid)
{
return(ServiceResultFactory.Fail <int>(validationResult));
}
await _repository.AddAsync(model);
var changes = await _repository.SaveChangesAsync();
if (changes == 0)
{
return(ServiceResultFactory.Fail <int>("Insert fails"));
}
return(ServiceResultFactory.Success(model.Id));
}
public async Task <ServiceResult <CompanyResponseViewModel> > GetSingle(int id)
{
var model = await _repository.GetSingleAsync(id);
if (model == null)
{
return(ServiceResultFactory.Success <CompanyResponseViewModel>(null));
}
var viewModel = new CompanyResponseViewModel
{
Id = model.Id,
CompanyName = model.Name,
RegNumber = model.RegNo,
ContactPerson = model.ContactPerson,
ContactEmail = model.ContactEmail,
ContactPhone = model.ContactPhone,
BusinessArea = model.BusinessArea,
//Address = model.Address, // TODO
City = model.City,
State = model.Status, // TODO
IsActive = model.IsActive
};
return(ServiceResultFactory.Success(viewModel));
}
public async Task <ServiceResult <int> > Create(InfoChannelMessageCreateOrUpdateRequestViewModel viewModel)
{
var model = new InfoChannelMessage();
MapViewModelToModel(viewModel, model);
model.Status = "1"; // TODO: What is status for?
var validator = new InfoChannelMessageCreateOrUpdateRequestViewModelValidator();
var validationResult = await validator.ValidateAsync(model);
if (!validationResult.IsValid)
{
return(ServiceResultFactory.Fail <int>(validationResult));
}
await _repository.AddAsync(model);
var changes = await _repository.SaveChangesAsync();
if (changes == 0)
{
return(ServiceResultFactory.Fail <int>("Insert fails"));
}
return(ServiceResultFactory.Success(model.Id));
}
public async Task <ServiceResult <bool> > Update(int companyId, int id, CompanyLicenceCreateOrUpdateRequestViewModel viewModel)
{
if (id <= 0)
{
throw new ArgumentException("Argument should be greater than 0", nameof(viewModel));
}
var model = await _repository.GetSingleByCompanyAsync(companyId, id);
if (model == null)
{
return(ServiceResultFactory.Fail <bool>("Item not found"));
}
MapViewModelToModel(viewModel, model);
var validator = new CompanyLicenceCreateOrUpdateRequestViewModelValidator();
var validationResult = await validator.ValidateAsync(model);
if (!validationResult.IsValid)
{
return(ServiceResultFactory.Fail <bool>(validationResult));
}
_repository.Update(model);
var changes = await _repository.SaveChangesAsync();
return(ServiceResultFactory.Success(changes > 0));
}
public ServiceResult <List <PersonDto> > GetAllMale()
{
var results = _personRepository.Search(new PersonSearchRequestDto {
Gender = GenderType.Male
});
var dtos = Mapper.Map <List <PersonDto> >(results);
return(ServiceResultFactory.Success(dtos));
}
public async Task <ServiceResult <int> > CreateBlog(AddBlogRequestViewModel viewModel)
{
await _unitOfWork.BeginTransaction();
var newBlogId = await _unitOfWork.BlogRepository.AddBlog(viewModel);
await _unitOfWork.SaveChangesAsync();
_unitOfWork.CommitTransaction();
return(ServiceResultFactory.Success(newBlogId));
}
public async Task <ServiceResult <bool> > Delete(int id)
{
if (id <= 0)
{
throw new ArgumentException("Argument should be greater than 0", nameof(id));
}
var model = await _repository.GetSingleAsync(id);
_repository.Delete(model);
var changes = await _repository.SaveChangesAsync();
return(ServiceResultFactory.Success(changes > 0));
}
public ServiceResult <PersonDto> GetSingle(int personId)
{
personId.ArgumentNotLessThan(0, nameof(personId), "Person id was invalid. Please supply positive id.");
var model = _personRepository.Get(personId);
if (model == null)
{
return(ServiceResultFactory.Fail <PersonDto>("Person with Id {personId} was not found."));
}
var dto = Mapper.Map <PersonDto>(model);
return(ServiceResultFactory.Success(dto));
}
public async Task <ServiceResult <PointOfSaleResponseViewModel> > GetSingle(int id)
{
var model = await _repository.GetSingleAsync(id);
if (model == null)
{
return(ServiceResultFactory.Success <PointOfSaleResponseViewModel>(null));
}
var viewModel = new PointOfSaleResponseViewModel
{
// TODO
};
return(ServiceResultFactory.Success(viewModel));
}
public async Task <ServiceResult <CompanyLicenceResponseViewModel> > GetSingle(int companyId, int id)
{
var model = await _repository.GetSingleByCompanyAsync(companyId, id);
if (model == null)
{
return(ServiceResultFactory.Success <CompanyLicenceResponseViewModel>(null));
}
var viewModel = new CompanyLicenceResponseViewModel
{
Id = model.Id,
LicenceKey = model.LicenceKey
};
return(ServiceResultFactory.Success(viewModel));
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model)
{
return(await HandleResultAsync(async() =>
{
var user = await _userManager.FindByNameAsync(model.Email);
if (user != null)
{
return ServiceResultFactory.Fail <IdentityResult>($"Error {StatusCodes.Status409Conflict}");
}
user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
return ServiceResultFactory.Success(result);
}));
}
public async Task <ServiceResult <InfoChannelMessageResponseViewModel> > GetSingle(int id)
{
var model = await _repository.GetSingleAsync(id);
if (model == null)
{
return(ServiceResultFactory.Success <InfoChannelMessageResponseViewModel>(null));
}
var viewModel = new InfoChannelMessageResponseViewModel
{
Id = model.Id,
IsVisible = model.Visible,
Subject = model.Title,
Message = model.Message
};
return(ServiceResultFactory.Success(viewModel));
}
public async Task <ServiceResult <bool> > Delete(int companyId, int id)
{
if (id <= 0)
{
throw new ArgumentException("Argument should be greater than 0", nameof(id));
}
var model = await _repository.GetSingleByCompanyAsync(companyId, id);
if (model == null)
{
return(ServiceResultFactory.Fail <bool>("Item not found"));
}
_repository.Delete(model);
var changes = await _repository.SaveChangesAsync();
return(ServiceResultFactory.Success(changes > 0));
}
public async Task <ServiceResult <PaginatedListResult <PointOfSalesResponseViewModel> > > Search(PointOfSalesRequestViewModel viewModel)
{
var paginatedListWithModel = await _repository.Search(viewModel);
// Mapping
List <PointOfSalesResponseViewModel> Mapping(List <Store> list)
{
return(list?
.Select(model => new PointOfSalesResponseViewModel
{
// TODO
})
.ToList());
}
var paginatedListWithViewModel = paginatedListWithModel.Copy(Mapping);
return(ServiceResultFactory.Success(paginatedListWithViewModel));
}
public async Task <ServiceResult <PaginatedListResult <InfoChannelMessagesDashboardResponseViewModel> > > InfoChannelMessages()
{
var paginatedListWithModel = await _infoChannelMessageRepository.Search(new InfoChannelMessagesRequestViewModel());
List <InfoChannelMessagesDashboardResponseViewModel> Mapping(List <InfoChannelMessage> list)
{
return(list?
.Select(model => new InfoChannelMessagesDashboardResponseViewModel
{
Id = model.Id,
Subject = model.Title,
Message = model.Message,
Date = model.UpdatedOn ?? model.CreatedOn
})
.ToList());
}
var paginatedListWithViewModel = paginatedListWithModel.Copy(Mapping);
return(ServiceResultFactory.Success(paginatedListWithViewModel));
}
public async Task <ServiceResult <CustomerResponseViewModel> > GetSingle(int companyId, int id)
{
var model = await _repository.GetSingleByCompanyAsync(companyId, id);
if (model == null)
{
return(ServiceResultFactory.Success <CustomerResponseViewModel>(null));
}
var viewModel = new CustomerResponseViewModel
{
Id = model.Id,
UsernameOrEmail = model.Email,
Name = model.Name,
CompanysMainUser = model.IsCompany,
//IsSeller = model.IsSeller, // TODO
//IsActive = model.IsActive, // TODO
};
return(ServiceResultFactory.Success(viewModel));
}
public async Task <ServiceResult <PaginatedListResult <ProductGroupsResponseViewModel> > > SearchListOfProductGroups(ProductGroupsRequestViewModel viewModel)
{
var paginatedListWithModel = await _repository.SearchProductCategories(viewModel);
// Mapping
List <ProductGroupsResponseViewModel> Mapping(List <ProductCategory> list)
{
return(list?
.Select(model => new ProductGroupsResponseViewModel
{
Id = model.Id,
Name = model.Name,
//KmPercent = model.
})
.ToList());
}
var paginatedListWithViewModel = paginatedListWithModel.Copy(Mapping);
return(ServiceResultFactory.Success(paginatedListWithViewModel));
}
public async Task <ServiceResult <PaginatedListResult <CompanyLicencesResponseViewModel> > > Search(CompanyLicencesRequestViewModel viewModel)
{
var paginatedListWithModel = await _repository.Search(viewModel);
List <CompanyLicencesResponseViewModel> Mapping(List <CompanyLicence> list)
{
return(list?
.Select(model => new CompanyLicencesResponseViewModel
{
Id = model.Id,
ExpiresOn = model.ValidToDate,
LicenceKey = model.LicenceKey,
LincenceUpdatingDateTime = model.ValidToDate,
Version = model.Version
})
.ToList());
}
var paginatedListWithViewModel = paginatedListWithModel.Copy(Mapping);
return(ServiceResultFactory.Success(paginatedListWithViewModel));
}
public async Task <ServiceResult <PaginatedListResult <InfoChannelMessagesResponseViewModel> > > Search(InfoChannelMessagesRequestViewModel viewModel)
{
var paginatedListWithModel = await _repository.Search(viewModel);
// Mapping
List <InfoChannelMessagesResponseViewModel> Mapping(List <InfoChannelMessage> list)
{
return(list?
.Select(model => new InfoChannelMessagesResponseViewModel
{
Id = model.Id,
Subject = model.Title,
Message = model.Message,
Date = model.VisibleUntil,
IsVisible = model.Visible
})
.ToList());
}
var paginatedListWithViewModel = paginatedListWithModel.Copy(Mapping);
return(ServiceResultFactory.Success(paginatedListWithViewModel));
}
public async Task <ServiceResult <bool> > Update(int id, ProductCreateOrUpdateRequestViewModel viewModel)
{
if (id <= 0)
{
throw new ArgumentException("Argument should be greater than 0", nameof(id));
}
var model = await _repository.GetSingleAsync(id);
MapViewModelToModel(viewModel, model);
var validator = new ProductCreateOrUpdateRequestViewModelValidator();
var validationResult = await validator.ValidateAsync(model);
if (!validationResult.IsValid)
{
return(ServiceResultFactory.Fail <bool>(validationResult));
}
_repository.Update(model);
var changes = await _repository.SaveChangesAsync();
return(ServiceResultFactory.Success(changes > 0));
}
public async Task <ServiceResult <SupplierResponseViewModel> > GetSingle(int id)
{
var model = await _repository.GetSingleAsync(id);
if (model == null)
{
return(ServiceResultFactory.Success <SupplierResponseViewModel>(null));
}
var viewModel = new SupplierResponseViewModel
{
CompanyId = model.CompanyId,
Name = model.Name,
RegistrationNumber = model.CompanyRegNumber,
Phone = model.Phone,
Email = model.Email,
Iban = model.BankIban,
BicSwift = model.BankSwift,
PaymentPeriodInDays = model.DeadlineDays,
Comment = model.Comment
};
return(ServiceResultFactory.Success(viewModel));
}
public async Task <ServiceResult <PaginatedListResult <TurnoverProductsResponseViewModel> > > TurnoverProducts(TurnoverProductsRequestViewModel viewModel) => ServiceResultFactory.Success(await _repository.TurnoverProducts(viewModel));
public async Task <ServiceResult <PaginatedListResult <SellerTurnoverResponseViewModel> > > SellerTurnover(SellerTurnoverRequestViewModel viewModel) => ServiceResultFactory.Success(await _repository.SellerTurnover(viewModel));
public async Task <ServiceResult <PaginatedListResult <WarehouseReportsResponseViewModel> > > WarehouseReports(WarehouseReportsRequestViewModel viewModel) => ServiceResultFactory.Success(await _repository.WarehouseReports(viewModel));
