public IEnumerable <FoodModel> Get()
{
//var repo = new CountingKsRepository(new CountingKsContext());
var results = TheRepository.GetAllFoodsWithMeasures()
.OrderBy(f => f.Description)
.Take(5)
.ToList()
.Select(f => TheModelFactory.Create(f));
return(results);
}
public IEnumerable <CourseModel> Get()
{
IQueryable <Course> query;
query = TheRepository.GetAllCourses();
var results = query
.ToList()
.Select(s => TheModelFactory.Create(s));
return(results);
}
public HttpResponseMessage Get(DateTime diaryid, int id)
{
var res = TheRepository.GetDiaryEntry(_identityService.CurrentUser, diaryid.Date, id);
if (res == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
return(Request.CreateResponse(HttpStatusCode.OK, TheModelFactory.Create(res)));
}
// POST api/ProductFamily
public HttpResponseMessage Post([FromBody] ProductFamily prodFamily)
{
try
{
_theProductFamilyRepo.Insert(prodFamily);
return(Request.CreateResponse(HttpStatusCode.Created, TheModelFactory.Create(prodFamily)));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public IHttpActionResult Get(int tagId)
{
var result = _tagService.GetTag(tagId);
if (result != null)
{
return(Ok(TheModelFactory.CreateTagModel(Url, "Tags", result)));
}
return(NotFound());
}
public IActionResult Get(int id)
{
var response = _categoryService.DataRepository.Get(id);
if (response != null)
{
var category = TheModelFactory.Create(response);
return(Ok(category));
}
return(NotFound());
}
public IActionResult Get(string id)
{
Guid courseId;
if (Guid.TryParse(id, out courseId))
{
var response = _courseRepository.Get(courseId);
var course = TheModelFactory.Create(response);
return(Ok(course));
}
return(NotFound());
}
public IEnumerable <DiaryModel> Get()
{
var usermane = _identityService.CurrentUser;
var results = TheRepository.GetDiaries(usermane)
.OrderByDescending(d => d.CurrentDate)
.Take(10)
.ToList()
.Select(d => TheModelFactory.Create(d));
return(results);
}
public HttpResponseMessage Get(DateTime diaryId)
{
var username = _identityService.CurrentUser;
var result = TheRepository.GetDiary(username, diaryId);
if (result == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
return(Request.CreateResponse(HttpStatusCode.OK, TheModelFactory.Create(result)));
}
public IEnumerable <DiaryModel> Get()
{
//use Thread.CurrentPrincipal.Identity.Name; but not very testable
var username = _identityService.CurrentUser;
var results = TheCountingKsRepository.GetDiaries(username)
.OrderByDescending(d => d.CurrentDate)
.Take(10)
.ToList()
.Select(d => TheModelFactory.Create(d));
return(results);
}
public object Get()
{
//var userName = Thread.CurrentPrincipal.Identity.Name;
var userName = _identityService.CurrentUser;
var results = TheRepository.GetDiaries(userName)
.OrderByDescending(d => d.CurrentDate)
.Take(10)
.ToList()
.Select(d => TheModelFactory.Create(d));
return(new object());
}
public IHttpActionResult Get(DateTime orderId, int id)
{
var userName = _identityService.CurrentUser;
var result = TheRepository.GetOrderEntry(userName, orderId, id);
if (result == null)
{
NotFound();
}
return(Ok(TheModelFactory.Create(result)));
}
public async Task <IHttpActionResult> CreateUser(CreateUserBindingModel createUserModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser()
{
UserName = createUserModel.Email,
Email = createUserModel.Email,
FirstName = createUserModel.FirstName,
LastName = createUserModel.LastName,
CompanyName = createUserModel.CompanyName,
CompanyAddress = createUserModel.CompanyAddress,
City = createUserModel.City,
State = createUserModel.State,
Country = createUserModel.Country,
PostalCode = createUserModel.PostalCode,
CompanyPhone = createUserModel.CompanyPhone
};
AppUserManager.UserValidator = new UserValidator <ApplicationUser>(AppUserManager)
{
AllowOnlyAlphanumericUserNames = false, RequireUniqueEmail = true
};
IdentityResult addUserResult = await this.AppUserManager.CreateAsync(user);
if (!addUserResult.Succeeded)
{
return(GetErrorResult(addUserResult));
}
string code = await this.AppUserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = new StringBuilder();
callbackUrl.Append(Request.RequestUri.Scheme);
callbackUrl.Append("://");
callbackUrl.Append(Request.RequestUri.Authority);
callbackUrl.Append("/ConfirmEmail?userId=");
callbackUrl.Append(user.Id);
callbackUrl.Append("&code=");
callbackUrl.Append(HttpUtility.UrlEncode(code));
await
this.AppUserManager.SendEmailAsync(user.Id, "Confirm your account",
"Please confirm your account by clicking " + callbackUrl);
Uri locationHeader = new Uri(Url.Link("GetUserById", new { id = user.Id }));
return(Created(locationHeader, TheModelFactory.Create(user)));
}
public HttpResponseMessage Get(bool includeMeasures = true, int page = 0)
{
IQueryable <Food> query;
if (includeMeasures)
{
query = TheRepository.GetAllFoodsWithMeasures()
.OrderBy(food => food.Description);
}
else
{
query = TheRepository.GetAllFoods()
.OrderBy(food => food.Description);
}
int totalCount = query.Count();
int totalPages = (int)Math.Ceiling((double)totalCount / PAGE_SIZE);
UrlHelper urlHelper = new UrlHelper(Request);
List <LinkModel> links = new List <LinkModel>();
if (page > 0)
{
links.Add(TheModelFactory.CreateLink(urlHelper.Link("Foods", new
{
page = page - 1,
}), "previousPage"));
}
if (page < totalPages - 1)
{
links.Add(TheModelFactory.CreateLink(urlHelper.Link("Foods", new
{
page = page + 1,
}), "nextPage"));
}
IEnumerable <FoodModel> results = query
.Skip(PAGE_SIZE * page)
.Take(PAGE_SIZE)
.ToList()
.Select(f => TheModelFactory.Create(f));
return(Request.CreateResponse(HttpStatusCode.OK, new
{
TotalCount = totalCount,
TotalPages = totalPages,
Links = links,
Results = results,
}));
}
//POST api/License
public HttpResponseMessage Post([FromBody] License license)
{
try
{
_theLicenseRepo.Insert(license);
return(Request.CreateResponse(HttpStatusCode.Created, TheModelFactory.Create(license)));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public HttpResponseMessage GetNewsByIdAndPermalink(int id, string permalink)
{
var article = magazineService.GetNewsByIdAndPermalink(id, permalink);
if (article == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No se encontró la noticia."));
}
var ads = magazineService.Api_Ads_GetByTags(article.Keywords, article.Category.MagazineId);
return(Request.CreateResponse(HttpStatusCode.OK, TheModelFactory.Article_Response(article, ads)));
}
public HttpResponseMessage GetFbVisitByMonth()
{
var user = userService.GetCurrentUser();
if (user == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Tienes que iniciar sesion."));
}
var items = influencerService.GetCounterByInfluencerAndMonth(user.UserId);
return(Request.CreateResponse(HttpStatusCode.OK, TheModelFactory.Create(items)));
}
public HttpResponseMessage ViewMagazineNew(string mGuid, int nId)
{
var article = magazineService.ApiGetNewById(mGuid, nId);
if (article == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No se encontró la noticia."));
}
var ads = magazineService.Api_Ads_GetByTags(article.Keywords, article.Category.MagazineId);
return(Request.CreateResponse(HttpStatusCode.OK, TheModelFactory.Article_Response(article, ads)));
}
// GET: api/Users
public HttpResponseMessage Get()
{
var userModels = TheRepository.GetAllUsers()
.ToList()
.Select(u => TheModelFactory.Create(u));
if (userModels == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
return(Request.CreateResponse(HttpStatusCode.OK, userModels));
}
public IHttpActionResult Get(int userid)
{
var user = TheRepository.GetUser(userid);
if (user == null)
{
return(NotFound());
}
UserModel um = TheModelFactory.Create(user);
return(Ok(um));
}
public IEnumerable <TaskApiModel> GetTasksForUser(string user, string searchFor, int pageSize, int pageIndex)
{
return(TasksService.GetNextTasksForUser(new GetNextTasksForUserRequest
{
User = user,
Domain = string.Empty,
WorkflowOid = Guid.Empty,
SearchFor = searchFor,
PageIndex = pageIndex,
PageSize = pageSize
}).Tasks
.Select(t => TheModelFactory.Create(t, GetAttachedDocuments(t.TaskOid))));
}
//POST api/Activation
public HttpResponseMessage Post([FromBody] Activation activation)
{
try
{
_theActivationRepo.Insert(activation);
return(Request.CreateResponse(HttpStatusCode.Created, TheModelFactory.Create(activation)));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public IHttpActionResult Post([FromBody] UserUriModel model)
{
if (TheRepository.GetUserByUserName(model.UserName) != null)
{
return(Conflict());
}
if (TheRepository.InsertUser(TheModelFactory.ParseUser(model)) && TheRepository.SaveAll())
{
return(Created(TheModelFactory.CreateUser(TheModelFactory.ParseUser(model)).Url, model));
}
return(BadRequest());
}
public IHttpActionResult Get(int id)
{
var certfication = TheRepository.GetCertificationbyCertificationId(id);
if (certfication == null)
{
return(NotFound());
}
else
{
return(Ok(TheModelFactory.Create(certfication)));
}
}
public IHttpActionResult Get(int id)
{
var soundtrack = TheRepository.GetSoundtrack(id);
if (soundtrack == null)
{
return(NotFound());
}
SoundtrackModel sm = TheModelFactory.Create(soundtrack);
return(Ok(sm));
}
public IHttpActionResult Put([FromBody] CertificateUriModel model)
{
if (TheRepository.GetCertificationByName(model.Name) != null)
{
return(Conflict());
}
if (TheRepository.UpdateCertification(TheModelFactory.Convert(model)) && TheRepository.SaveAll())
{
return(Created(TheModelFactory.Create(TheModelFactory.Convert(model)).Url, model));
}
return(BadRequest());
}
public IHttpActionResult Get(int courseID, int page = 0, int pageSize = 10)
{
IQueryable <Student> query;
query = TheRepository.GetEnrolledStudentsInCourse(courseID).OrderBy(s => s.FirstName);
var totalCount = query.Count();
var result = query.Skip(page * pageSize)
.Take(pageSize).ToList().Select(s => TheModelFactory.CreateSummary(s));
return(Ok(result));
}
public async Task <IHttpActionResult> GetCart()
{
var cart = await GetCurrentFullCart();
if (cart == null)
{
return(NotFound());
}
var model = TheModelFactory.Create(cart);
return(Ok(model));
}
public async Task <IHttpActionResult> GetSiteTemplate(int id)
{
var siteTemplate =
await this.DB.SiteTemplates
.SingleOrDefaultAsync(st => st.Id == id && st.EntityStatus != EntityStatus.Removed);
if (siteTemplate == null)
{
return(NotFound());
}
return(Ok(TheModelFactory.Create(siteTemplate)));
}
// GET: api/Soundtrack
public HttpResponseMessage Get()
{
var slideModel = TheRepository.GetAllSoundtracks()
.ToList()
.Select(st => TheModelFactory.Create(st));
if (slideModel == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
return(Request.CreateResponse(HttpStatusCode.OK, slideModel));
}
