public RequestsViewModel(IQueryable<Request> requests, int pageNo, int pageSize, User user, RequestFilters requestFilter)
        {
            User = user;
            RequestFilter = requestFilter;

            CurrentPage = pageNo;
            PageSize = pageSize;
            TotalResults = requests.Count();

            TotalPages = (int)Math.Ceiling(TotalResults / (float)PageSize);

            if (TotalPages > CurrentPage)
            {
                NextPage = CurrentPage + 1;
            }

            if (CurrentPage > 1)
            {
                PreviousPage = CurrentPage - 1;
            }

            Count = (TotalResults > pageNo * pageSize) ? pageSize : TotalResults - (pageNo - 1) * pageSize;

            if (Count > 0)
            {
                Requests = requests.Skip((pageNo - 1) * pageSize).Take(Count).AsEnumerable().Select(i => new RequestViewModel(user, i));
            }
            else
            {
                Count = 0;

                Requests = new List<RequestViewModel>();
            }
        }
Пример #2
0
        public void SendChangePasswordMail(User user)
        {
            var link = string.Format("{0}/ChangePassword?token={1}", domainName, user.ResetToken);

            var body = LoadMailTemplate("ChangePassword", new { User = user, Url = link });

            SendMail(new MailAddress[] { new MailAddress(repo.GetEmailFromUsername(user.Username), user.FirstName + " " + user.LastName) }, "Server Request Reset Password", body);
        }
        public RequestFormViewModel(Request request, User user, IEnumerable<ApplicationType> applicationTypes, IEnumerable<Location> locations, 
            IEnumerable<ServerType> serverTypes, IEnumerable<PortType> portTypes, IEnumerable<IPRequestForm.Models.OperatingSystem> operatingSystems, 
            RequestFormViews requestFormView)
        {
            this.RequestFormView = requestFormView;
            this.OperatingSystems = operatingSystems;
            this.PortTypes = portTypes;
            this.ServerTypes = serverTypes;
            this.Locations = locations;
            this.ApplicationTypes = applicationTypes;

            RequestFormView = requestFormView;

            RequestUser = request.User;

            this.RequestOwner = request.Owner;

            RequestId = request.Id;

            Date = request.SubmissionDate;
            BusinessService = request.BusinessService;
            ApplicationName = request.ApplicationName;

            RequestApplicationTypes = request.RequestApplicationTypes.Select(i => i.ApplicationType);

            NetBIOSName = request.Virtualization.NetBIOSName;
            DNSName = request.Virtualization.DNSName;

            Notes = request.Notes;

            Deleted = request.Deleted;
            DeletedDate = request.DeleteDate;

            ServerLocation = request.Virtualization.Server.Location;
            ServerType = request.Virtualization.Server.ServerType;

            ServerTypeName = (ServerTypes)request.Virtualization.Server.ServerType.Id;

            if (ServerTypeName == IPRequestForm.ViewModels.ServerTypes.Blades)
            {
                RackChassisPort = request.Virtualization.Server.BladeChassi.RackChassisPort;
                NICTeaming = request.Virtualization.Server.BladeChassi.NICTeaming;
            }

            this.OperatingSystem = request.Virtualization.OperatingSystem;

            //ShowPolicies = (!Roles.IsUserInRole("Users") || request.UserId == user.Id);

            ShowPolicies = true;

            var reqs = request.RequestPorts.AsQueryable();

            if (user.Id != request.OwnerId & !Roles.IsUserInRole("Security") & !Roles.IsUserInRole("Communication"))
            {
                reqs = reqs.Where(x => x.Port.UserId == user.Id);
            }

            Policies = reqs.Select(i => new Policy
            {
                Id = i.Port.Id,
                IPAddress = CommonFunctions.IPDotted(i.Port.IP.Address),
                SubnetMaskBits = i.Port.SubnetMaskId != null ? (int?)BitConverter.ToUInt32(i.Port.SubnetMask.Address.Reverse().ToArray(), 0).BitsSetCountNaive() : null,
                PortType = i.Port.PortType,
                StartPortNumber = i.Port.StartPortNumber,
                EndPortNumber = i.Port.EndPortNumber,
                PortDirection = (PortDirections)i.Port.PortDirection.Id,
                StartDate = i.Port.StartDate,
                EndDate = i.Port.EndDate
            });
        }
 /// <summary>
 /// Create a new User object.
 /// </summary>
 /// <param name="id">Initial value of the Id property.</param>
 /// <param name="firstName">Initial value of the FirstName property.</param>
 /// <param name="lastName">Initial value of the LastName property.</param>
 /// <param name="username">Initial value of the Username property.</param>
 /// <param name="membershipUserId">Initial value of the MembershipUserId property.</param>
 /// <param name="departmentId">Initial value of the DepartmentId property.</param>
 public static User CreateUser(global::System.Int32 id, global::System.String firstName, global::System.String lastName, global::System.String username, global::System.Guid membershipUserId, global::System.Int32 departmentId)
 {
     User user = new User();
     user.Id = id;
     user.FirstName = firstName;
     user.LastName = lastName;
     user.Username = username;
     user.MembershipUserId = membershipUserId;
     user.DepartmentId = departmentId;
     return user;
 }
 public RequestFormViewModel(Request request, User user, RequestFormViews requestFormView)
     : this(request, user, null, null, null, null, null, requestFormView)
 {
 }
        public IQueryable<Request> GetUserRequests(User user)
        {
            var loggedInUser = GetCurrentUser();

            var requests = db.Requests.AsQueryable();

            if (Roles.IsUserInRole("Users"))
            {
                var departmentUserIds = loggedInUser.Department.Users.Select(k => k.Id);

                requests = requests.Where(i => departmentUserIds.Contains(i.UserId));
            }

            if (user.Id != loggedInUser.Id)
            {
                if (Roles.IsUserInRole(user.Username, "Users"))
                {
                    requests = requests.Where(i => i.UserId == user.Id || i.OwnerId == user.Id || i.OriginalRequest.Requests.Any(x => x.UserId == user.Id));
                }
                else if (Roles.IsUserInRole(user.Username, "Security"))
                {
                    requests = requests.Where(i => i.UserId == user.Id || i.SecurityActions.Count > 0 && i.SecurityActions.OrderByDescending(x => x.Id).FirstOrDefault().UserId == user.Id);
                }
                else if (Roles.IsUserInRole(user.Username, "Communication"))
                {
                    requests = requests.Where(i => i.UserId == user.Id || i.CommunicationActions.Count > 0 && i.CommunicationActions.OrderByDescending(x => x.Id).FirstOrDefault().UserId == user.Id);
                }
            }

            var reqs = db.Requests.AsQueryable();

            requests = requests.Where(x => !reqs.Any(y => y.OldRequestId == x.Id));

            return requests.OrderByDescending(x => x.SubmissionDate);
        }
 /// <summary>
 /// Deprecated Method for adding a new object to the Users EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead.
 /// </summary>
 public void AddToUsers(User user)
 {
     base.AddObject("Users", user);
 }
 public void GenerateResetToken(User user)
 {
     user.ResetToken = Guid.NewGuid().ToString();
 }
        public User CreateUser(string firstName, string lastName, string username, int departmentId, string[] roleNames)
        {
            var password = Membership.GeneratePassword(8, 3); //DateTime.Now.Ticks.ToString("x");

            var user = Membership.CreateUser(GetUsernameFromEmail(username), password, GetEmailFromUsername(username));

            Roles.AddUserToRoles(username, roleNames);

            var dbUser = new User
            {
                Username = GetUsernameFromEmail(username),
                FirstName = firstName,
                LastName = lastName,
                DepartmentId = departmentId,
                MembershipUserId = (Guid)user.ProviderUserKey
            };

            db.Users.AddObject(dbUser);

            GenerateResetToken(dbUser);

            return dbUser;
        }
 public void ClearResetToken(User user)
 {
     user.ResetToken = null;
 }
        public RequestViewModel(User user, Request request, IEnumerable<Vlan> vlans, IEnumerable<Switch> switches, 
            IEnumerable<SwitchModule> switchModules, IEnumerable<SwitchPort> switchPorts, RequestFilters requestFilter)
        {
            RequestFilter = requestFilter;
            User = user;
            Switches = switches;
            SwitchModules = switchModules;
            SwitchPorts = switchPorts;

            var repo = new RequestRepository();

            OlderRequest = repo.GetOlderRequest(request);

            NewerRequest = repo.GetNewerRequest(request);

            Request = new RequestFormViewModel(request, user, RequestFormViews.View);

            var lastApprovedAction = repo.GetLastApprovedSecurityAction(request);

            if (lastApprovedAction != null)
            {
                Vlan = lastApprovedAction.Vlan;
            }

            // Get the last security action of this request version.
            if (request.SecurityActions.Count > 0)
            {
                LastSecurityAction = request.SecurityActions.OrderByDescending(x => x.Id).First();
            }

            // Get the last communication action of this request version.
            if (request.CommunicationActions.Count > 0)
            {
                LastCommunicationAction = request.CommunicationActions.OrderByDescending(x => x.Id).First();

                Notes = LastCommunicationAction.Notes;
            }

            var lastCompletedAction = repo.GetLastCompletedCommunicationAction(request);

            if (lastCompletedAction != null)
            {
                IPAddress = CommonFunctions.IPDotted(lastCompletedAction.ServerIP.IP.Address);

                if (lastCompletedAction.Completed == true)
                {
                    if (Request.ServerType.Id == (int)ServerTypes.Standalone)
                    {
                        SwitchIPAddress = CommonFunctions.IPDotted(lastCompletedAction.ServerIP.SwitchPort.SwitchModule.Switch.IP.Address);
                        SwitchName = lastCompletedAction.ServerIP.SwitchPort.SwitchModule.Switch.Name;
                        SwitchNumber = lastCompletedAction.ServerIP.SwitchPort.SwitchModule.Switch.StackableNumber;

                        SwitchModuleNumber = lastCompletedAction.ServerIP.SwitchPort.SwitchModule.Number;
                        SwitchPortNumber = lastCompletedAction.ServerIP.SwitchPort.Port;
                    }
                }
            }

            Vlans = vlans;

            Logs = new List<Log>();

            var reqs = repo.GetRequestUpdates(request.OriginalRequest).ToList();

            Logs.AddRange(reqs.Select(x => new Log
            {
                User = x.User,
                Date = x.SubmissionDate,
                Notes = x.Notes,
                LogAction = (x.Id == x.OriginalId) ? LogActions.RequestCreated : LogActions.RequestUpdated
            }));

            Logs.AddRange(reqs.SelectMany(x => x.SecurityActions.Select(action => new Log
            {
                User = action.User,
                Date = action.Date,
                Notes = action.Notes,
                LogAction = action.Approved == true ? LogActions.SecurityApproved :
                            (action.Approved == false ? LogActions.SecurityRejected :
                            (action.Assigned ? LogActions.SecurityAssigned :
                            LogActions.SecurityReleased))
            })));

            Logs.AddRange(reqs.SelectMany(x => x.CommunicationActions.Select(action => new Log
            {
                User = action.User,
                Date = action.Date,
                Notes = action.Notes,
                LogAction = action.Completed == true ? LogActions.CommunicationCompleted :
                            (action.Completed == false ? LogActions.CommunicationProcessing :
                            (action.Assigned ? LogActions.CommunicationAssigned :
                            LogActions.CommunicationReleased))
            })));

            Logs = Logs.OrderByDescending(x => x.Date).ToList();
        }
 public RequestViewModel(User user, Request request)
     : this(user, request, null, null, null, null, RequestFilters.All)
 {
 }