public async Task DeleteAsync(FashionSubCategory parameters)
{
var FashionSubCategory = Uow.Repository <FashionSubCategory>().FindByKey(parameters.FashionSubCategoryId);
await Uow.RegisterDeletedAsync(FashionSubCategory);
await Uow.CommitAsync();
}
public IEnumerable <PatologiaDto> GetAll()
{
var listapatologia = Uow.Repository <Domain.Core.Entities.Patologia>().GetAll();
var listaDto = Mapper.Map <IEnumerable <Domain.Core.Entities.Patologia>, IEnumerable <PatologiaDto> >(listapatologia.ToList());
return(listaDto);
}
public async Task <object> GetBy(FacebookUserModel parameters)
{
var isMobile = await Uow.Repository <FacebookUser>().SingleOrDefaultAsync(t => t.MobileNo == parameters.Email || t.Email == parameters.Email);
if (isMobile != null && PasswordHash.VerifySignature(parameters.Password, isMobile.Password, isMobile.Salt))
{
isMobile.Token = await ApplicationTokenProvider.GetTokenAsync(isMobile);
return(isMobile);
}
else
{
var isEmail = await Uow.Repository <FacebookUser>().SingleOrDefaultAsync(t => t.Email == parameters.Email);
if (isEmail != null && PasswordHash.VerifySignature(parameters.Password, isEmail.Password, isEmail.Salt))
{
isMobile.Token = await ApplicationTokenProvider.GetTokenAsync(isMobile);
return(isMobile);
}
else
{
return(0);
}
// return "Invalid credentials";
}
}
public void Insert(AlimentoDto alimento)
{
var alimentoNuevo = Mapper.Map <AlimentoDto, Domain.Core.Entities.Alimento>(alimento);
Uow.Repository <Domain.Core.Entities.Alimento>().Insert((Domain.Core.Entities.Alimento)alimentoNuevo);
Uow.Commit();
}
public async Task <object> GetAsync(BookIssue parameters)
{
//vBookIssue vBookIssue = new vBookIssue();
return(await Uow.Repository <vBookIssue>().AllAsync());
//throw new NotImplementedException();
}
public IEnumerable <MotivoConsultaDto> GetAll()
{
var listaMc = Uow.Repository <Domain.Core.Entities.MotivoConsulta>().GetAll();
var listaDto = Mapper.Map <IEnumerable <Domain.Core.Entities.MotivoConsulta>, IEnumerable <MotivoConsultaDto> >(listaMc.ToList());
return(listaDto);
}
public async Task DeleteAsync(Seller parameters)
{
var Seller = Uow.Repository <Seller>().FindBy(t => t.SellerId == parameters.SellerId);
await Uow.RegisterDeletedAsync(Seller);
await Uow.CommitAsync();
}
public void Update(FamiliarDto familiar)
{
var familiarModificar = Mapper.Map <FamiliarDto, Domain.Core.Entities.Familiar>(familiar);
Uow.Repository <Domain.Core.Entities.Familiar>().Update(familiarModificar);
Uow.Commit();
}
// PUT api/Trip/5
private IHttpActionResult PutTrip(int id, Trip trip)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != trip.Id)
{
return(BadRequest());
}
Uow.Repository <Trip>().Update(trip);
try
{
Uow.Save();
}
catch (DbUpdateConcurrencyException)
{
if (!TripExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public IHttpActionResult Post(Order order)
{
var date = DateTime.Now;
order.OrderDate = date;
var message = OrderDomain.Post(order);
if (message == "Order Placed")
{
var orderList = Uow.Repository <Order>().All();
foreach (var item in orderList)
{
if (item.UserId == order.UserId)
{
var dateDatabase = (item.OrderDate).ToString("hh:mm:ss tt");
var dateController = date.ToString("hh:mm:ss tt");
if (dateDatabase == dateController)
{
return(Ok(new { message = message, data = item.OrderId }));
}
}
}
return(Ok("error"));
}
else
{
return(Ok(new { message = "order not placed" }));
}
}
public IEnumerable <FamiliarDto> GetAll()
{
var listaFamiliar = Uow.Repository <Domain.Core.Entities.Familiar>().GetAll();
var listaDto = Mapper.Map <IEnumerable <Domain.Core.Entities.Familiar>, IEnumerable <FamiliarDto> >(listaFamiliar.ToList());
return(listaDto);
}
public void Update(EmpleadoDto empleado)
{
var empleadoModificar = Mapper.Map <EmpleadoDto, Domain.Core.Entities.Empleado>(empleado);
Uow.Repository <Domain.Core.Entities.Empleado>().Update(empleadoModificar);
Uow.Commit();
}
public void Insert(EmpleadoDto empleado)
{
var nuevoEmpleado = Mapper.Map <EmpleadoDto, Domain.Core.Entities.Empleado>(empleado);
Uow.Repository <Domain.Core.Entities.Empleado>().Insert(nuevoEmpleado);
Uow.Commit();
}
public EmpleadoDto GetById(Guid empleadoId)
{
var listaEmpleado = Uow.Repository <Domain.Core.Entities.Empleado>().GetById(empleadoId);
var listaDto = Mapper.Map <Domain.Core.Entities.Empleado, EmpleadoDto>(listaEmpleado);
return(listaDto);
}
public void Update(PacienteDto paciente)
{
var pacienteActualizar = Mapper.Map <PacienteDto, Domain.Core.Entities.Paciente>(paciente);
Uow.Repository <Domain.Core.Entities.Paciente>().Update(pacienteActualizar);
Uow.Commit();
}
public IHttpActionResult DeleteTrip(int id)
{
try
{
Trip trip = Uow.Repository <Trip>().Find(id);
if (trip == null)
{
return(NotFound());
}
//find tconnects that reference the steps owned by this trip
var stepsForTrip = Uow.Repository <Step>().Query().Get().Include(s => s.Block).Where(s => s.TripId.Equals(trip.Id)).Select(i => i.Id).ToList();
List <TConnect> tconn = Uow.Repository <TConnect>().Query().Get().Where(t => stepsForTrip.Any(s => s.Equals(t.InboundStepId))).ToList();
foreach (TConnect tc in tconn)
{
//Delete the tconnect
// TConnect tonnect = Uow.Repository<Trip>().Find(tconn.id);
Uow.Repository <TConnect>().Delete(tc);
}
//Delete the trip (cascade delete will do the steps).
Uow.Repository <Trip>().Delete(trip);
Uow.Save();
return(Ok(trip));
}
catch (Exception ex)
{
string msg = RecordException(ex, "TripController.DeleteTrip");
HttpResponseMessage responseMessage = Request.CreateErrorResponse(HttpStatusCode.BadRequest, msg);
throw new HttpResponseException(responseMessage);
}
}
public async Task DeleteAsync(Registered parameters)
{
var register = Uow.Repository <Registered>().FindByKey(parameters.Id);
await Uow.RegisterDeletedAsync(register);
await Uow.CommitAsync();
}
public IEnumerable <EmpresaDto> GetAll()
{
var listaEmpresa = Uow.Repository <Domain.Core.Entities.Empresa>().GetAll();
var listaDto = Mapper.Map <IEnumerable <Domain.Core.Entities.Empresa>, IEnumerable <EmpresaDto> >(listaEmpresa.ToList());
return(listaDto);
}
public void Update(MotivoConsultaDto motivoConsulta)
{
var motivoConsultaModificar = Mapper.Map <MotivoConsultaDto, Domain.Core.Entities.MotivoConsulta>(motivoConsulta);
Uow.Repository <Domain.Core.Entities.MotivoConsulta>().Update(motivoConsultaModificar);
Uow.Commit();
}
public void Update(EmpresaDto empresa)
{
var empresaModificar = Mapper.Map <EmpresaDto, Domain.Core.Entities.Empresa>(empresa);
Uow.Repository <Domain.Core.Entities.Empresa>().Update(empresaModificar);
Uow.Commit();
}
public IHttpActionResult Post(UserModel user)
{
User userTemp = new User();
if (user != null)
{
if (user.Email != null)
{
var userObj = Uow.Repository <User>().FirstOrDefault(t => t.Email == user.Email);
if (userObj != null)
{
return(Ok("Same Email Exists"));
}
}
var passwordHash = AppUow.PasswordEncryption.Encrypt(user.Password);
userTemp.Password = passwordHash.PasswordHash;
userTemp.Salt = passwordHash.Salt;
userTemp.FirstName = user.FirstName;
userTemp.LastName = user.LastName;
userTemp.Email = user.Email;
userTemp.Contact = user.Contact;
userTemp.Address = user.Address;
userTemp.RoleId = 2;
userTemp.GenderId = user.GenderId;
Uow.Save();
}
return(Ok(UserDomain.PostUser(userTemp)));
}
public async Task DeleteAsync(AppUser parameters)
{
var user = Uow.Repository <AppUser>().FirstOrDefault(t => t.AppUserId == parameters.AppUserId);
await Uow.RegisterDeletedAsync(user);
await Uow.CommitAsync();
}
public void Update(AlimentoDto alimento)
{
var alimentoModificar = Mapper.Map <AlimentoDto, Domain.Core.Entities.Alimento>(alimento);
Uow.Repository <Domain.Core.Entities.Alimento>().Update((Domain.Core.Entities.Alimento)alimentoModificar);
Uow.Commit();
}
public IHttpActionResult Post(LoginModel user)
{
if (user.email != null && user.password != null)
{
var data = Uow.Repository <User>().FirstOrDefault(c => c.Email == user.email);
if (data != null)
{
byte[] userPassword = AppUow.PasswordEncryption.Encrypt(user.password, data.Salt);
if (AppUow.PasswordEncryption.VerifyPassword(data.Password, userPassword))
{
return(Ok(new { data = data, message = true }));
}
else
{
return(Ok(4));
}
}
else
{
return(Ok(5));
}
}
else
{
return(Ok("Please Enter Your Email and Password"));
}
}
public async Task DeleteAsync(UserDetail parameters)
{
var user = Uow.Repository <UserDetail>().FindByKey(parameters.PaytmUserId);
await Uow.RegisterDeletedAsync(user);
await Uow.CommitAsync();
}
public IHttpActionResult PutForgotPassword(UserModel user)
{
if (user.Email != null)
{
var data = Uow.Repository <User>().FirstOrDefault(c => c.Email == user.Email);
if (data != null)
{
var passwordHash = AppUow.PasswordEncryption.Encrypt("Yournewpassword1");
data.Password = passwordHash.PasswordHash;
data.Salt = passwordHash.Salt;
var message = UserDomain.PutUser(data);
SendMail sendMail = new SendMail();
bool mail = sendMail.sendSMTPMail(user.Email, "PasswordReset", "Yournewpassword1");
if (message == "User Edited.")
{
return(Ok("successfull"));
}
else
{
return(Ok("error"));
}
}
else
{
return(Ok("Email Does Not Exist"));
}
}
else
{
return(Ok("Please Enter Your Email"));
}
}
public void Update(PatologiaDto patologia)
{
var patologiaModificar = Mapper.Map <PatologiaDto, Domain.Core.Entities.Patologia>(patologia);
Uow.Repository <Domain.Core.Entities.Patologia>().Update(patologiaModificar);
Uow.Commit();
}
public void Insert(PacienteDto paciente)
{
var pacienteNuevo = Mapper.Map <PacienteDto, Domain.Core.Entities.Paciente>(paciente);
Uow.Repository <Domain.Core.Entities.Paciente>().Insert(pacienteNuevo);
Uow.Commit();
}
public async Task DeleteAsync(SellerProduct parameters)
{
var SellerProduct = Uow.Repository <SellerProduct>().FindByKey(parameters.SellerProductId);
await Uow.RegisterDeletedAsync(SellerProduct);
await Uow.CommitAsync();
}
public IHttpActionResult Put(ProductModel product)
{
Product productTemp = AdminDomain.GetBy(product.ProductId);
productTemp.ProductName = product.ProductName;
productTemp.ProductDescription = product.ProductDescription;
productTemp.Quantity = product.Quantity;
productTemp.Cost = product.Cost;
productTemp.Comment = product.Comment;
var newSubCategoryId = Uow.Repository <SubCategory>().FirstOrDefault(c => c.SubCategoryName == product.SubCategory);
productTemp.SubCategoryId = newSubCategoryId.SubCategoryId;
var newDiscountId = Uow.Repository <Discount>().FirstOrDefault(c => c.Percentage == product.Discount);
productTemp.DiscountId = newDiscountId.DiscountId;
var newBrandId = Uow.Repository <Brand>().FirstOrDefault(c => c.BrandName == product.Brand);
productTemp.BrandId = newBrandId.BrandId;
var newProduct = Uow.Repository <Product>().FirstOrDefault(c => c.ProductId == product.ProductId);
var fil = new FileCollection()
{
url = (newProduct.ProductImage).BaseStringJpeg()
};
if (product.ProductImageBaseString == fil.url)
{
productTemp.ProductImage = newProduct.ProductImage;
}
else
{
productTemp.ProductImage = product.ProductImage;
}
return(Ok(AdminDomain.PutProduct(productTemp)));
}
