public PipelineExecutionResult Execute(Category subject)
{
var idToDelete = subject.Name;
logging.Log <DeleteCategoryFromKaching>("Deleting tag: " + subject.Name + " in Ka-ching");
var config = KachingConfiguration.Get();
var url = config.TagsIntegrationURL;
if (url.StartsWith("https://", StringComparison.Ordinal))
{
var idsToDelete = new List <string>();
idsToDelete.Add(idToDelete);
var result = Synchronizer.Delete(idsToDelete, url);
if (result == PipelineExecutionResult.Error)
{
return(result);
}
}
var folders = new CategoryConverter(logging).GetFolders();
var foldersUrl = config.FoldersIntegrationURL;
if (!foldersUrl.StartsWith("https://", StringComparison.Ordinal))
{
return(PipelineExecutionResult.Success);
}
return(Synchronizer.Post(folders, foldersUrl));
}
public IHttpActionResult PostCategory(CategoryDTO category)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Category c = CategoryConverter.DTOToDAL(category);
CategoryBLL.Add(c);
try
{
Global.SaveChanges();
}
catch (DbUpdateException)
{
if (CategoryExists(category.code))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = category.code }, category));
}
public void should_convert_from_string(string input, string expected)
{
var converter = new CategoryConverter();
var result = converter.ConvertFromString(input, Mock.Of <IReaderRow>(), null);
result.Should().Be(expected);
}
public async Task <CategoryDto> Create(CategoryDto item)
{
var cat = await FindByTitle(item.Title);
if (cat != null)
{
return(cat);
}
if (item.Title == "" || item.Title == null)
{
return(null);
}
var result = await _context.Categories.AddAsync(new Category { Title = item.Title });
await _context.SaveChangesAsync();
if (result.Entity != null)
{
return(CategoryConverter.Convert((result.Entity)));
}
else
{
return(null);
}
}
public List <CategoryModel> GetAllCategories()
{
var entities = _iCategoryDAO.GetAllCategories();
var models = CategoryConverter.EntitiesToModels(entities);
return(models);
}
public static List <CategoryDTO> GetCategories()
{
using (GetCoffeeDBEntities db = new GetCoffeeDBEntities())
{
return(CategoryConverter.DALListToDTO(db.Categories.ToList()));
}
}
public static CategoryDTO GetCategoryById(long id)
{
using (GetCoffeeDBEntities db = new GetCoffeeDBEntities())
{
return(CategoryConverter.DALToDTO(db.Categories.Find(id)));
}
}
public async Task <CategoryDTO> Add(CreateCategoryDTO categoryDTO)
{
if (categoryDTO == null)
{
return(null);
}
if (categoryDTO.ParentCategoryId != null && await Get(categoryDTO.ParentCategoryId.Value) == null)
{
return(null);
}
var entity = await unitOfWork.Repository <Category>().Add(CategoryConverter.Convert(categoryDTO));
if (entity == null)
{
return(null);
}
if (entity.ParentCategoryId != null)
{
entity.ParentCategory = await unitOfWork.Repository <Category>().Get(entity.ParentCategoryId.Value);
}
return(CategoryConverter.Convert(entity));
}
public async Task <bool> Update(CategoryDto item)
{
_context.Categories.Update(CategoryConverter.Convert(item));
await _context.SaveChangesAsync();
return(true);
}
public void Read_multiple()
{
// Arrange
var json = "['category1','category2','category3']";
var textReader = new StringReader(json);
var jsonReader = new JsonTextReader(textReader);
var objectType = (Type)null;
var existingValue = (object)null;
var serializer = new JsonSerializer();
var converter = new CategoryConverter();
// Act
jsonReader.Read();
var result = converter.ReadJson(jsonReader, objectType, existingValue, serializer);
// Assert
result.ShouldNotBeNull();
result.ShouldBeOfType <string[]>();
var resultAsArray = (string[])result;
resultAsArray.Length.ShouldBe(3);
resultAsArray[0].ShouldBe("category1");
resultAsArray[1].ShouldBe("category2");
resultAsArray[2].ShouldBe("category3");
}
public async Task <List <CategoryDto> > GetAllAsync()
{
var categories = CategoryConverter.Convert(
await _context.Categories
.ToListAsync());
return(categories);
}
public async Task <CategoryDto> GetByIdAsync(int id)
{
return(CategoryConverter.Convert(
await _context.Categories
// .Include(c => c.PostCategory)
// .ThenInclude(pc => pc.Post)
.FirstOrDefaultAsync(c => c.Id == id)));
}
public async Task <CategoryDto> CreateAsync(CategoryDto item)
{
var category = _context.Categories.Add(
CategoryConverter.Convert(item));
await _context.SaveChangesAsync();
return(CategoryConverter.Convert(category.Entity));
}
public void CanConvert()
{
// Act
var converter = new CategoryConverter();
// Assert
converter.CanConvert(null).ShouldBeTrue();
}
public async Task <CategoryDto> Create(CategoryDto item)
{
var result = await _context.Categories.AddAsync(CategoryConverter.Convert(item));
await _context.SaveChangesAsync();
return(CategoryConverter.Convert(result.Entity));
}
public async Task <ItemDto> GetById(Guid id)
{
var item = ItemConverter.Convert(_context.Items.AsNoTracking().First(x => x.Id == id));
var category = CategoryConverter.Convert(_context.Categories.AsNoTracking().First(x => x.Id == item.CategoryId));
item.Category = category;
item.CategoryName = category.Name;
return(item);
}
public void Properties()
{
// Act
var converter = new CategoryConverter();
// Assert
converter.CanRead.ShouldBeTrue();
converter.CanWrite.ShouldBeFalse();
}
public CourseService(IDataFacade facade)
{
_crsConv = new CourseConverter();
_userConv = new UserConverter();
_secConverter = new SectionConverter();
_catConv = new CategoryConverter();
_lesConv = new LessonConverter();
_facade = facade;
}
private List <int> ConverComingCategories(List <string> comingCategories)
{
List <int> categories = new List <int>();
foreach (string comingCategory in comingCategories)
{
categories.Add((int)CategoryConverter.RusStringToEnum(comingCategory));
}
return(categories);
}
public async Task <CategoryDTO> Get(long id)
{
var category = await GetCategoryEntity(id);
if (category == null)
{
return(null);
}
return(CategoryConverter.Convert(category));
}
public async Task <List <CategoryDTO> > GetCategories()
{
var categories = unitOfWork.Repository <Category>().GetQueryable().ToList();
if (categories == null)
{
return(null);
}
return(await Task.FromResult(CategoryConverter.Convert(categories)));
}
public async Task <CategoryDTO> Get(long id)
{
var category = await unitOfWork.Repository <Category>().Get(id);
if (category == null)
{
return(null);
}
return(CategoryConverter.Convert(category));
}
private DbProduct SetProductData(AddEditProduct productFromView)
{
DbProduct newDbProduct = new DbProduct();
newDbProduct.DbProductId = String.IsNullOrEmpty(productFromView.ProductId) ? GeneratorId.GenerateId() : productFromView.ProductId;
newDbProduct.DbProductName = productFromView.ProductName;
newDbProduct.DbProductWeight = Decimal.Parse(productFromView.ProductWeight.Replace(".", ","));
newDbProduct.DbProductCategory = (int)CategoryConverter.RusStringToEnum(productFromView.ProductCategory);
newDbProduct.DbImageRes = productFromView.ProductImageRes;
return(newDbProduct);
}
public async Task CreateAsync(Category entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
var category = CategoryConverter.Convert(entity);
await _session.InsertAsync(category);
}
public async Task <CategoryDto> FindByTitle(string title)
{
try
{
return(CategoryConverter.Convert(await _context.Categories.FirstOrDefaultAsync(a => a.Title.ToLower() == title.ToLower())));
}
catch
{
return(null);
}
}
public async Task <List <ItemDto> > GetByCategory(Guid id)
{
var category = CategoryConverter.Convert(_context.Categories.AsNoTracking().FirstOrDefault(x => x.Id == id));
var items = ItemConverter.Convert(_context.Items.AsNoTracking().ToList().FindAll(x => x.CategoryId == id));
foreach (var item in items)
{
item.Category = category;
item.CategoryName = category.Name;
}
return(items);
}
public async Task <CategoryDTO> Update(UpdateCategoryDTO dto) // update dto
{
if (dto == null)
{
return(null);
}
var entity = CategoryConverter.Convert(dto);
entity = await unitOfWork.Repository <Category>().Update(entity);
return(CategoryConverter.Convert(entity));
}
public void Write()
{
// Arrange
var writer = (JsonWriter)null;
var value = (object)null;
var serializer = (JsonSerializer)null;
var converter = new CategoryConverter();
// Act
Should.Throw <NotImplementedException>(() => converter.WriteJson(writer, value, serializer));
}
public async Task <List <CategoryDTO> > GetAll()
{
var categories = unitOfWork.Repository <Category>().GetQueryable()
.Include(x => x.ParentCategory)
.Where(x => x.IsDeleted != true)
.ToList();
if (categories == null)
{
return(null);
}
return(await Task.FromResult(CategoryConverter.Convert(categories)));
}
protected void StartCategoryImportButton_Click(Object sender, EventArgs e)
{
var converter = new CategoryConverter(logger);
var folders = converter.GetFolders();
var tags = converter.GetAllTags();
PostFolders(folders);
PostTags(tags);
var count = tags.Count;
ImportStatus.Text = $"Initiated export of {count} categories.";
}