public void When_Index_Return_Valid_Data()
{
//arrange
var getAllBookResponse = new GetAllBookResponse();
var category = new CategoryResponse
{
Id = 1,
Name = "Programming"
};
getAllBookResponse.Data = new List <BookResponse>
{
new BookResponse
{
Id = 1,
Title = "Book1",
Category = category
},
new BookResponse
{
Id = 2,
Title = "Book2",
Category = category
},
};
getAllBookResponse.Success = true;
_bookService.GetAllBook().Returns(getAllBookResponse);
//act
var result = _bookController.Index() as ViewResult;
var resultModel = result.Model as BookGetAllViewModel;
//assert
Assert.AreEqual(resultModel.Books.Count, getAllBookResponse.Data.Count);
}
public CategoryResponse GetCategoryById([FromBody] CategoryRequest categoryRequest)
{
CategoryResponse response;
try
{
CategoryResponse Authenticated = Authentication.CheckAuthentication(categoryRequest.Authentication.Email, categoryRequest.Authentication.Password);
if (Authenticated != null)
{
return(Authenticated);
}
Category _category = _categoryService.GetById(categoryRequest.Category.Id);
return(CreateResponse.ReturnResponse(_category));
}
catch (Exception exception)
{
return(response = new CategoryResponse()
{
status = new Models.Attribute.Status()
{
Code = (int)Enums.MessageCode.Error,
Message = Enums.MessageCode.Error.ToString() + exception.Message
}
});
}
}
public async Task <IActionResult> GetCategory([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var category = await _context.Category.Include(a => a.Events)
.FirstOrDefaultAsync(a => a.Id == id);
var response = new CategoryResponse
{
Description = category.Description,
Name = category.Name,
Id = category.Id,
Events = category.Events.Select(p => new EventResponse
{
Id = p.Id,
Name = p.Name,
Duration = p.Duration,
EventDate = p.EventDate,
People = p.People,
Description = p.Description,
}).ToList(),
};
if (category == null)
{
return(NotFound());
}
return(Ok(response));
}
public async Task <ActionResult <Category> > PostCategory(CategoryAddRequest category)
{
var cat = _mapper.Map <Category>(category.Data);
cat.Status = true;
_context.Categories.Add(cat);
await _context.SaveChangesAsync();
var myCategory = _mapper.Map <DtoCategory>(cat);
myCategory = CreateLinksForCategory(myCategory);
var getResponse = new CategoryResponse
{
Value = myCategory,
Meta = new DtoMeta
{
Date = DateTimeOffset.UtcNow,
ResponseId = Guid.NewGuid(),
Status = Status.Succeeded
}
};
return(CreatedAtAction("GetCategory", new { id = cat.CategoryId }, getResponse));
}
public async Task <IActionResult> Create([FromBody] CreateCategoryRequest CategoryRequst)
{
var category = new Category
{
ArabicName = CategoryRequst.ArabicName,
EnglishName = CategoryRequst.EnglishName,
ImageUrl = CategoryRequst.ImageUrl,
Status = CategoryRequst.Status
};
var status = await _CategoryService.CreateCategoryAsync(category);
if (status == -1)
{
return(Conflict(new ErrorResponse
{
message = "Dublicate Entry",
status = Conflict().StatusCode
}));
}
if (status == 1)
{
var response = new CategoryResponse {
Id = category.Id
};
return(Ok(response));
}
return(NotFound(new ErrorResponse
{
message = "Not Found",
status = NotFound().StatusCode
}));
}
public object Get(POS.Dto.Category request)
{
var response = new CategoryResponse();
try
{
if (request.Id.HasValue)
{
var category = GetById(request.Id.Value);
response.Category.Add(category);
response.Result = "1 Category was found";
}
else
{
//Get all
response.Category = GetByAll();
response.Result = "All Categorys was found";
}
}
catch (Exception)
{
}
return response;
}
public CategoryResponse Add(Category cat)
{
CategoryResponse response = new CategoryResponse();
if (string.IsNullOrEmpty(cat.CategoryName))
{
response.Success = false;
response.Message = "Category Name cannot be false";
return(response);
}
try
{
using (var context = new PersonalBlogEntities())
{
context.Categories.Add(cat);
context.SaveChanges();
response.Success = true;
}
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <IActionResult> Create([FromBody] CreateContactUsRequest createContact)
{
var contactUs = new ContactUs
{
Email = createContact.Email,
Phone = createContact.Phone,
WebSite = createContact.WebSite,
Address = createContact.Address
};
var status = await _contactUsService.CreateContactUsAsync(contactUs);
if (status == 1)
{
var response = new CategoryResponse {
Id = contactUs.Id
};
return(Ok(response));
}
return(NotFound(new ErrorResponse
{
message = "Not Found",
status = NotFound().StatusCode
}));
}
public ActionResult DeleteCategory(string categoryName)
{
PolicyGrinder grinder = PolicyGrinderFactory.Synthesize();
CategoryResponse category = grinder.GetOneCategory(categoryName);
return(View(category));
}
public CategoryResponse AddResult([FromBody] Result result)
{
//Job dbJob = new Job();
//PropertyCopier<JobApiModel, Job>.Copy(job, dbJob);
CategoryResponse apiResponse = new CategoryResponse();
try
{
if (!_unityOfWork.Result.IsAlreadyAvailable(result))
{
result.UpdatedOn = DateTime.Now;
result.CreatedOn = DateTime.Now;
_unityOfWork.Result.Add(result);
_unityOfWork.Save();
}
else
{
result.UpdatedOn = DateTime.Now;
_unityOfWork.Result.Update(result);
_unityOfWork.Save();
}
apiResponse.Message = "Successfully Inserted ";
apiResponse.Code = 200;
apiResponse.Description = $"Result successfully updated for the job";
return(apiResponse);
}
catch (Exception ex)
{
_logger.LogInformation(ex.StackTrace);
return(apiResponse);
}
}
public async Task <CategoryResponse> GetCategoryById(string id)
{
try
{
var response = await _httpClient.GetAsync($"{id}");
if (response.IsSuccessStatusCode)
{
var responseStream = await response.Content.ReadAsStreamAsync();
StreamReader reader = new StreamReader(responseStream);
string text = reader.ReadToEnd();
categoryResponse = JsonConvert.DeserializeObject <CategoryResponse>(text);
}
else
{
_logger.LogError("Error : category api url or something");
}
}
catch (Exception ex)
{
_logger.LogInformation(ex.Message);
}
return(categoryResponse);
}
public async Task <IEnumerable <CategoryResponse> > GetCategoriesAsync()
{
var categoriesKeys = await _dataSource.Database.SetMembersAsync("cat");
if (!categoriesKeys.Any())
{
return(null);
}
List <CategoryResponse> categories = new List <CategoryResponse>(categoriesKeys.Length);
for (int i = 0; i < categoriesKeys.Length; i++)
{
var category = new CategoryResponse()
{
Id = categoriesKeys[i],
Name = await _dataSource.Database.StringGetAsync($"cat:{categoriesKeys[i]}")
};
categories.Add(category);
var subcategoriesKey = await _dataSource.Database.SetMembersAsync($"cat:{category.Id}:subcat");
if (subcategoriesKey.Any())
{
List <CategoryResponse> subCategories = new List <CategoryResponse>(subcategoriesKey.Length);
category.Categories = subCategories;
for (int j = 0; j < subcategoriesKey.Length; j++)
{
var subCategory = new CategoryResponse()
{
Id = subcategoriesKey[j],
Name = await _dataSource.Database.StringGetAsync($"cat:{subcategoriesKey[j]}")
};
subCategories.Add(subCategory);
var grandChildCategoriesKey = await _dataSource.Database.SetMembersAsync($"cat:{category.Id}:subcat:{subCategory.Id}");
if (grandChildCategoriesKey.Any())
{
var grandChildCategories = new List <CategoryResponse>();
subCategory.Categories = grandChildCategories;
for (int k = 0; k < grandChildCategoriesKey.Length; k++)
{
var grandChildCategory = new CategoryResponse()
{
Id = grandChildCategoriesKey[k],
Name = await _dataSource.Database.StringGetAsync($"cat:{grandChildCategoriesKey[k]}")
};
grandChildCategories.Add(grandChildCategory);
}
}
}
}
}
return(categories);
}
public CategoryResponse UpdateJob([FromBody] JobApiModel job)
{
Job dbJob = new Job();
PropertyCopier <JobApiModel, Job> .Copy(job, dbJob);
CategoryResponse apiResponse = new CategoryResponse();
try
{
if (!_unityOfWork.Job.IsUpdatable(dbJob))
{
_unityOfWork.Job.Update(dbJob);
_unityOfWork.Save();
apiResponse.Message = "Successfully Updated ";
apiResponse.Code = 200;
apiResponse.Description = $"{job.PostShortName} successfully Updated in database";
return(apiResponse);
}
apiResponse.Message = "This is Already Available in Database";
apiResponse.Code = 409;
apiResponse.Description = $"{job.PostShortName} Already Available in Database";
return(apiResponse);
}
catch (Exception ex)
{
_logger.LogInformation(ex.StackTrace);
return(apiResponse);
}
}
public static ProductResponse MapToResponse(this Product product)
{
if (product is null)
{
throw new ArgumentNullException(nameof(product));
}
var response = new ProductResponse
{
Id = product.Id,
LongDescription = product.LongDescription,
ShortDescription = product.ShortDescription,
OwnerId = product.OwnerId,
ImageName = product.Id.ToString()
};
if (product.ProductCategories != null && product.ProductCategories.Any())
{
foreach (var productCateg in product.ProductCategories)
{
var categoryResponse = new CategoryResponse
{
Id = productCateg.CategoryId,
Name = productCateg.Category?.Name
};
response.Categories.Add(categoryResponse);
}
}
return(response);
}
public async Task <CategoryResponse> Add(CategoryRequest request)
{
CategoryResponse response = new CategoryResponse();
try
{
Category category = new Category();
if (!(await iCategory.IsDuplicate(request.CategoryName)))
{
category.CategoryName = request.CategoryName;
category.Description = request.Description;
category.Created = DateTime.Now;
category.CreatedBy = request.CurrentLogin;
category.RowStatus = true;
if (await iCategory.Add <Category>(category))
{
return(response);
}
response.Message = "Failed to Add Category";
response.IsSuccess = false;
}
else
{
response.Message = "Category is Duplicated with existing";
response.IsSuccess = false;
}
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = "Something Error in Our System : " + ex.Message;
}
return(response);
}
public static CategoryResponse ReturnResponse(List <Category> _categories)
{
CategoryResponse response;
if (_categories != null)
{
return(response = new CategoryResponse()
{
status = new Models.Attribute.Status()
{
Code = (int)MessageCode.Successful,
Message = GetDescriptionOfEnum(MessageCode.Successful)
},
categories = _categories
});
}
else
{
return(response = new CategoryResponse()
{
status = new Models.Attribute.Status()
{
Code = (int)MessageCode.Error,
Message = GetDescriptionOfEnum(MessageCode.Unsuccessful)
}
});
}
}
public async void getAllCategory(CommonRequest commonRequest, Action success, Action <CategoryResponse> failed)
{
bool IsNetwork = true;//await DependencyService.Get<IMediaService>().CheckNewworkConnectivity();
if (IsNetwork)
{
var url = string.Format("{0}getAllCategories.php", _settingsManager.ApiHost);
await Task.Run(async() =>
{
Dictionary <string, string> head = GetHeaders();
var result = _apiProvider.Get <CategoryResponse>(url, null);
if (result.IsSuccessful)
{
if (success != null)
{
categoryResponse = result.Result;
success.Invoke();
}
}
else
{
failed.Invoke(result.Result);
}
});
}
else
{
UserDialogs.Instance.HideLoading(); UserDialogs.Instance.Alert(error, null, "OK");
}
}
public CategoryResponse UpdateCategory([FromBody] Category category)
{
CategoryResponse apiResponse = new CategoryResponse();
try
{
if (!_unityOfWork.Category.IsUpdatable(category))
{
_unityOfWork.Category.Update(category);
_unityOfWork.Save();
apiResponse.Message = "Successfully Updated ";
apiResponse.Code = 200;
apiResponse.Description = $"{category.Name} successfully Updated in database";
return(apiResponse);
}
apiResponse.Message = "Category Already Available in Database";
apiResponse.Code = 409;
apiResponse.Description = $"{category.Name} Already Available in Database";
return(apiResponse);
}
catch (Exception ex)
{
_logger.LogInformation(ex.StackTrace);
return(apiResponse);
}
}
public CategoryResponse Edit(Category cat)
{
CategoryResponse response = new CategoryResponse();
if (cat.CategoryId == 0 || string.IsNullOrEmpty(cat.CategoryName))
{
response.Success = false;
response.Message = "Required field was null";
return(response);
}
try
{
using (var context = new PersonalBlogEntities())
{
var toEdit = context.Categories.Where(c => c.CategoryId == cat.CategoryId).First();
toEdit = cat;
context.SaveChanges();
response.Success = true;
}
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public CategoryResponse GetAll()
{
CategoryResponse response = new CategoryResponse();
using (var context = new PersonalBlogEntities())
{
try
{
response.Categories = context.Categories.ToList();
if (response.Categories.Count == 0)
{
response.Success = false;
response.Message = "Nothing found.";
return(response);
}
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
}
public CategoryResponse GetById(int id)
{
CategoryResponse response = new CategoryResponse();
if (id == 0)
{
response.Success = false;
response.Message = "Value for Id not passed in.";
return(response);
}
using (var context = new PersonalBlogEntities())
{
try
{
response.Categories = context.Categories
.Where(c => c.CategoryId == id)
.ToList();
if (response.Categories.Count == 0)
{
response.Success = false;
response.Message = "Nothing found.";
return(response);
}
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
}
public IActionResult Add([FromBody] CategoryRequest categoryRequest)
{
Category category = AutoMap.Map <CategoryRequest, Category>(categoryRequest);
CategoryResponse categoryResponses = AutoMap.Map <Category, CategoryResponse>(this._categoryService.Add(category));
return(Ok(new BaseResponse <CategoryResponse>(categoryResponses)));
}
public IActionResult Get(int id)
{
Category category = this._categoryService.Get(id);
CategoryResponse categoryResponses = AutoMap.Map <Category, CategoryResponse>(category);
return(Ok(new BaseResponse <CategoryResponse>(categoryResponses)));
}
public void GetAllCats()
{
CategoryResponse response = repo.GetAll();
Category actual = response.Categories.Where(c => c.CategoryId == 1).First();
Assert.AreEqual(true, response.Success);
Assert.AreEqual("Tech", actual.CategoryName);
}
/// <summary>
/// Retrieve all the categories
/// </summary>
/// <returns>Details of all the categories</returns>
public CategoryResponse GetCategories()
{
CategoryResponse categoryResponse = new CategoryResponse();
List <Category> categoryList = categoryRepo.RetrieveAllCategories();
categoryResponse.categoryList = categoryList;
return(categoryResponse);
}
private void GetCategories()
{
string endpoint = String.Format("api/categories/{0}", this.Token);
CategoryResponse response = JsonConvert.DeserializeObject <CategoryResponse>(this.ExecuteGet(endpoint));
this.ValidateResponse(response, endpoint);
this.Categories = response.data;
}
public async Task <HttpResponseMessage> Update(MT_Category_Master CMD)
{
Db = con.SurgeryCenterDb(CMD.Slug);
CategoryResponse Response = new CategoryResponse();
try
{
MT_Category_Master CMaster = new MT_Category_Master();
List <MT_Category_Detail> CDetails = new List <MT_Category_Detail>();
Query ObjQuery = Db.Collection("MT_Category_Master").WhereEqualTo("CM_UniqueID", CMD.CM_Unique_ID);
QuerySnapshot ObjQuerySnap = await ObjQuery.GetSnapshotAsync();
if (ObjQuerySnap != null)
{
CMaster = ObjQuerySnap.Documents[0].ConvertTo <MT_Category_Master>();
if (CMaster.CM_Detail != null)
{
foreach (MT_Category_Detail detail in CMaster.CM_Detail)
{
if (detail.CD_Unique_ID == CMD.CM_Detail[0].CD_Unique_ID)
{
detail.CD_Is_Assigned = CMD.CM_Detail[0].CD_Is_Assigned;
CDetails.Add(detail);
}
else
{
CDetails.Add(detail);
}
}
}
}
Dictionary <string, object> initialData = new Dictionary <string, object>
{
{ "CM_Detail", CDetails }
};
DocumentReference docRef = Db.Collection("MT_Category_Master").Document(CMD.CM_Unique_ID);
WriteResult Result = await docRef.UpdateAsync(initialData);
if (Result != null)
{
Response.Status = con.StatusSuccess;
Response.Message = con.MessageSuccess;
Response.Data = CMD;
}
else
{
Response.Status = con.StatusNotUpdate;
Response.Message = con.MessageNotUpdate;
Response.Data = null;
}
}
catch (Exception ex)
{
Response.Status = con.StatusFailed;
Response.Message = con.MessageFailed + ", Exception : " + ex.Message;
}
return(ConvertToJSON(Response));
}
/// <summary>
/// Add a new category
/// </summary>
/// <param name="categoryDetails">The category details</param>
/// <returns>The created category details</returns>
public CategoryResponse AddCategory(Category categoryDetails)
{
CategoryResponse categoryResponse = new CategoryResponse();
Category category = categoryRepo.CreateNewCategory(categoryDetails);
categoryResponse.category = category;
categoryResponse.message = "Category is added succefully";
return(categoryResponse);
}
/// <summary>
/// Retrieve category details of selected category
/// </summary>
/// <param name="categoryId">The category id</param>
/// <returns>Details of all the category for selected category type</returns>
public CategoryResponse GetCategory(string categoryId)
{
CategoryResponse categoryResponse = new CategoryResponse();
Category category = categoryRepo.RetrieveCategory(categoryId);
categoryResponse.category = category;
categoryResponse.message = "Fetching of categories";
return(categoryResponse);
}
/// <summary>
/// Deletes the category
/// </summary>
/// <param name="categoryId">The category id</param>
/// <returns>Details of category deleted</returns>
public CategoryResponse DeleteCategory(string categoryId)
{
CategoryResponse categoryResponse = new CategoryResponse();
Category category = categoryRepo.DeleteCategory(categoryId);
categoryResponse.category = category;
categoryResponse.message = "Deleted Animal Successfully";
return(categoryResponse);
}
/// <summary>
/// Upadtes the category
/// </summary>
/// <param name="categoryId">The category id</param>
/// <param name="categoryDetails">The category details</param>
/// <returns>Details of the updated category</returns>
public CategoryResponse UpdateCategory(Category categoryDetails)
{
CategoryResponse categoryResponse = new CategoryResponse();
Category category = categoryRepo.UpdateCategory(categoryDetails);
categoryResponse.category = category;
categoryResponse.message = "Successfully updated the category";
return(categoryResponse);
}
