public ActionResult Incluir(ModelUsuario usuario)
{
try
{
if (ModelState.IsValid)
{
using (var context = new ContextEntities()) {
new UsuarioDB(context).SalvarUsuario(usuario);
}
ViewBag.mensagem = "Usuario salvo com sucesso.";
Response.Redirect("~/Usuario");
}
ViewData["grupos"] = listaGrupos();
}
catch (Exception e)
{
Response.Redirect("~/Usuario");
}
return(View(usuario));
}
public static Boolean VerificarRecursoPermitido(int grupo, int recurso)
{
using (var ctx = new ContextEntities())
{
return(ctx.Recurso.Count(r => r.Grupo.Any(g => g.codigo == grupo) && r.codigo == recurso) > 0);
}
}
/// <summary>
/// Gets the entity object given it's type.
/// </summary>
/// <typeparam name="T">The IEntity type to retrieve.</typeparam>
/// <returns>A reference to the IEntity object or null if none was found.</returns>
public virtual T GetContextEntity <T>() where T : IEntity
{
if (ContextEntities.ContainsKey(typeof(T)))
{
return(( T )ContextEntities[typeof(T)].Value);
}
return(default);
/// <summary>
/// Gets the entity object given it's type.
/// </summary>
/// <returns>A reference to the IEntity object or null if none was found.</returns>
public virtual IEntity GetContextEntity(Type entityType)
{
if (ContextEntities.ContainsKey(entityType))
{
return(ContextEntities[entityType].Value);
}
return(default);
public DropOffFacilityController(ContextEntities context) : base(context)
{
context = _context;
dropOffFacilityRepository = new DropOffFacilityRepository(context);
facilityItemRespository = new FacilityItemRespository(context);
websiteUserRepository = new WebsiteUserRepository(context);
orderRepository = new OrderRepository(context);
}
public ProductController(ContextEntities context) : base(context)
{
context = _context;
productRepository = new ProductRepository(context);
productTypeRepository = new ProductTypeRepository(context);
productCategoryRepository = new ProductCategoryRepository(context);
websiteUserRepository = new WebsiteUserRepository(context);
productViewModel = new ProductViewModel();
}
/// <summary>
/// Adds the context entities from headers.
/// </summary>
protected virtual void AddContextEntitiesFromHeaders()
{
foreach (var kvp in Headers)
{
//
// Skip any header that isn't an entity context header.
//
if (!kvp.Key.StartsWith("X-ENTITYCONTEXT-", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
//
// Determine the the entity type in question.
//
var entityName = kvp.Key.Substring(16);
var type = EntityTypeCache.All()
.Where(a => a.IsEntity)
.FirstOrDefault(a => a.FriendlyName.Equals(entityName, StringComparison.InvariantCultureIgnoreCase))
?.GetEntityType();
string entityKey = kvp.Value.First();
//
// If we got an unknown type or no Id/Guid then skip.
//
if (type == null || entityKey.IsNullOrWhiteSpace())
{
continue;
}
//
// Lazy load the entity so we don't actually load if it is never
// accessed.
//
ContextEntities.AddOrReplace(type, new Lazy <IEntity>(() =>
{
IEntity entity = null;
if (int.TryParse(entityKey, out int entityId))
{
entity = Reflection.GetIEntityForEntityType(type, entityId);
}
else if (Guid.TryParse(entityKey, out Guid entityGuid))
{
entity = Reflection.GetIEntityForEntityType(type, entityGuid);
}
if (entity != null && entity is IHasAttributes attributedEntity)
{
Helper.LoadAttributes(attributedEntity);
}
return(entity);
}));
}
}
public FacilityEmployeeController(ContextEntities context) : base(context)
{
context = _context;
user = new UserManager()
{
Name = "default",
Password = null
};
facilityEmployeeRepository = new FacilityEmployeeRepository(context);
}
public WebsiteUserController(ContextEntities context) : base(context)
{
context = _context;
user = new UserManager()
{
UserName = "******",
Password = null
};
websiteUserRepository = new WebsiteUserRepository(context);
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Init" /> event.
/// </summary>
/// <param name="e">An <see cref="T:System.EventArgs" /> object that contains the event data.</param>
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
if (ContextEntities.ContainsKey("Rock.Model.Person"))
{
Person = ContextEntities["Rock.Model.Person"] as Person;
if (Person == null)
{
Person = new Person();
}
}
}
public static string MenuLateral(int grupo)
{
ContextEntities context = new ContextEntities();
var recursos = context.Recurso.Where(s => s.TipoRecurso.codigo == 1)
.Where(s => s.Grupo.Any(g => g.codigo == grupo));
string html = "";
foreach (Recurso r in recursos)
{
html += MenuList(r, grupo);
}
return(html);
}
public ActionResult Login(Usuario u)
{
// esta action trata o post (login)
if (ModelState.IsValid) //verifica se é válido
{
using (ContextEntities dc = new ContextEntities())
{
var v = dc.Usuarios.Where(a => a.Nome_usuario.Equals(u.Nome_usuario) && a.Senha.Equals(u.Senha)).FirstOrDefault();
if (v != null)
{
Session["usuarioLogadoID"] = v.Id.ToString();
Session["nomeUsuarioLogado"] = v.Nome_usuario.ToString();
return(RedirectToAction("Index"));
}
}
}
return(View(u));
}
private bool IsValid(ModelUsuario usuario)
{
//TODO INCLUIR USUARIO
bool isValid = false;
try
{
using (ContextEntities db = new ContextEntities())
{
var usuarioRs = db.Usuario.FirstOrDefault(u => u.login == usuario.login);
if (usuarioRs != null && usuarioRs.senha == usuario.senha)
{
usuario.grupo = new ModelGrupo()
{
codigo = usuarioRs.Grupo.codigo,
descricao = usuarioRs.Grupo.descricao
};
isValid = true;
FormsAuthentication.SetAuthCookie(usuario.login, false);
var cookie = Response.Cookies["grupo"];
if (cookie != null)
{
cookie["codigo"] = usuario.grupo.codigo.ToString();
}
var httpCookie = Response.Cookies["grupo"];
if (httpCookie != null)
{
httpCookie["nome"] = usuario.grupo.descricao;
}
}
}
}
catch (Exception e)
{
isValid = false;
}
return(isValid);
}
/// <summary>
/// Adds the context entities for page.
/// </summary>
/// <param name="pageCache">The page cache.</param>
internal virtual void AddContextEntitiesForPage(PageCache pageCache)
{
foreach (var pageContext in pageCache.PageContexts)
{
var entityType = EntityTypeCache.Get(pageContext.Key)?.GetEntityType();
if (entityType == null)
{
continue;
}
int?contextId = GetPageParameter(pageContext.Value).AsIntegerOrNull();
if (contextId.HasValue)
{
ContextEntities.AddOrReplace(entityType, new Lazy <IEntity>(() =>
{
var entity = Reflection.GetIEntityForEntityType(entityType, contextId.Value);
if (entity != null && entity is IHasAttributes attributedEntity)
{
Helper.LoadAttributes(attributedEntity);
}
return(entity);
}));
}
Guid?contextGuid = GetPageParameter(pageContext.Value).AsGuidOrNull();
if (contextGuid.HasValue)
{
ContextEntities.AddOrReplace(entityType, new Lazy <IEntity>(() =>
{
var entity = Reflection.GetIEntityForEntityType(entityType, contextGuid.Value);
if (entity != null && entity is IHasAttributes attributedEntity)
{
Helper.LoadAttributes(attributedEntity);
}
return(entity);
}));
}
}
}
public AdminUserController(ContextEntities context) : base(context)
{
context = _context;
user = new UserManager()
{
Name = "defualt",
Password = null
};
adminUserRepository = new AdminUserRepository(context);
websiteUserRepository = new WebsiteUserRepository(context);
productRepository = new ProductRepository(context);
reviewRepository = new ReviewRepository(context);
orderRepository = new OrderRepository(context);
dropOffFacilityRepository = new DropOffFacilityRepository(context);
facilityEmployeeRepository = new FacilityEmployeeRepository(context);
flaggedOrderRepository = new FlaggedOrderRepository(context);
flaggedProductRepository = new FlaggedProductRepository(context);
flaggedReviewRepository = new FlaggedReviewRepository(context);
flaggedUserRepository = new FlaggedUserRepository(context);
productCategoryRepository = new ProductCategoryRepository(context);
productTypeRepository = new ProductTypeRepository(context);
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
GroupService groupService = new GroupService();
SortProperty sortProperty = gGroups.SortProperty;
var qry = groupService.Queryable();
List <int> groupTypeIds = AttributeValue("GroupTypes").SplitDelimitedValues().Select(a => int.Parse(a)).ToList();
if (groupTypeIds.Count > 0)
{
qry = qry.Where(a => groupTypeIds.Contains(a.GroupTypeId));
}
if (AttributeValue("LimittoSecurityRoleGroups").FromTrueFalse())
{
qry = qry.Where(a => a.IsSecurityRole);
}
if (ContextEntities.ContainsKey("Rock.Model.Group"))
{
Group parentGroup = ContextEntities["Rock.Model.Group"] as Group;
if (parentGroup != null)
{
qry = qry.Where(a => a.IsAncestorOfGroup(parentGroup.Id));
}
}
if (sortProperty != null)
{
gGroups.DataSource = qry.Sort(sortProperty).ToList();
}
else
{
gGroups.DataSource = qry.OrderBy(p => p.Name).ToList();
}
gGroups.DataBind();
}
public MainController(ContextEntities context)
{
_context = context;
}
public PacienteDb(ContextEntities context)
{
this.Context = context;
}
public ProductCategoryRepository(ContextEntities context) : base(context)
{
}
public BillingInfoRepository(ContextEntities context) : base(context)
{
}
public Repository(ContextEntities context)
{
_context = context;
_dbset = _context.Set <T>();
}
public FlaggedOrderRepository(ContextEntities context) : base(context)
{
}
public FacilityEmployeeRepository(ContextEntities context) : base(context)
{
}
public TransactionHistoryRepository(ContextEntities context) : base(context)
{
}
public ReviewController(ContextEntities context) : base(context)
{
context = _context;
reviewRepository = new ReviewRepository(context);
}
public ReviewRepository(ContextEntities context) : base(context)
{
}
public ProductTypeRepository(ContextEntities context) : base(context)
{
}
public WebsiteUserController(ContextEntities context) : base(context)
{
context = _context;
websiteUserRepository = new WebsiteUserRepository(context);
}
public AdminUserRepository(ContextEntities context) : base(context)
{
}
public WebsiteUserRepository(ContextEntities context) : base(context)
{
}
