Exemple #1
0
        public RESTStatus GetWindowsLicData(SQLLib sql, object dummy, NetworkConnectionInfo ni, string id)
        {
            if (ni.HasAcl(ACLFlags.ChangeServerSettings) == false)
            {
                ni.Error   = "Access denied";
                ni.ErrorID = ErrorFlags.AccessDenied;
                return(RESTStatus.Denied);
            }

            if (string.IsNullOrWhiteSpace(id) == true)
            {
                ni.Error   = "Missing Data";
                ni.ErrorID = ErrorFlags.InvalidData;
                return(RESTStatus.Fail);
            }

            lock (ni.sqllock)
            {
                if (Computers.MachineExists(sql, id) == false)
                {
                    ni.Error   = "Invalid MachineID";
                    ni.ErrorID = ErrorFlags.InvalidValue;
                    return(RESTStatus.Fail);
                }
            }

            lock (ni.sqllock)
            {
                SqlDataReader dr = sql.ExecSQLReader("SELECT * FROM WindowsLic WHERE MachineID=@m",
                                                     new SQLParam("@m", id));
                if (dr.HasRows == false)
                {
                    dr.Close();
                    ni.Error   = "No Data";
                    ni.ErrorID = ErrorFlags.NoData;
                    return(RESTStatus.Fail);
                }

                WindowsLicData = new WindowsLic();
                dr.Read();

                WindowsLicData.Description          = Convert.ToString(dr["Description"]);
                WindowsLicData.GracePeriodRemaining = Convert.ToInt64(dr["GracePeriodRemaining"]);
                WindowsLicData.LicenseFamily        = Convert.ToString(dr["LicenseFamily"]);
                WindowsLicData.LicenseStatus        = Convert.ToInt64(dr["LicenseStatus"]);
                WindowsLicData.LicenseStatusText    = Convert.ToString(dr["LicenseStatusText"]);
                WindowsLicData.MachineID            = Convert.ToString(dr["MachineID"]);
                WindowsLicData.Name = Convert.ToString(dr["Name"]);
                WindowsLicData.PartialProductKey = Convert.ToString(dr["PartialProductKey"]);
                WindowsLicData.ProductKeyChannel = Convert.ToString(dr["ProductKeyChannel"]);
                WindowsLicData.ProductKeyID      = Convert.ToString(dr["ProductKeyID"]);
                WindowsLicData.ProductKeyID2     = Convert.ToString(dr["ProductKeyID2"]);
                WindowsLicData.Reported          = SQLLib.GetDTUTC(dr["Reported"]);

                dr.Close();
            }

            return(RESTStatus.Success);
        }
Exemple #2
0
        public RESTStatus GetStartupItems(SQLLib sql, object dummy, NetworkConnectionInfo ni, string id)
        {
            if (ni.HasAcl(ACLFlags.ChangeServerSettings) == false)
            {
                ni.Error   = "Access denied";
                ni.ErrorID = ErrorFlags.AccessDenied;
                return(RESTStatus.Denied);
            }

            StartupsRep       = new ListStartupItemReport();
            StartupsRep.Items = new List <StartupItemFull>();

            lock (ni.sqllock)
            {
                SqlDataReader dr;
                if (string.IsNullOrWhiteSpace(id) == true)
                {
                    dr = sql.ExecSQLReader("select * from Startups inner join ComputerAccounts on ComputerAccounts.MachineID=Startups.MachineID left outer join UsersList on UsersList.SID=HKCUUser AND UsersList.MachineID=Startups.MachineID order by Location,[Key]");
                }
                else
                {
                    if (Computers.MachineExists(sql, id) == false)
                    {
                        ni.Error   = "Invalid data";
                        ni.ErrorID = ErrorFlags.InvalidData;
                        return(RESTStatus.NotFound);
                    }

                    dr = sql.ExecSQLReader("select * from Startups inner join ComputerAccounts on ComputerAccounts.MachineID=Startups.MachineID left outer join UsersList on UsersList.SID=HKCUUser AND UsersList.MachineID=Startups.MachineID WHERE ComputerAccounts.MachineID=@m order by Location,[Key]",
                                           new SQLParam("@m", id));
                }

                while (dr.Read())
                {
                    StartupItemFull ar = new StartupItemFull();
                    ar.Computername = Convert.ToString(dr["Computername"]);
                    ar.DT           = SQLLib.GetDTUTC(dr["DT"]);
                    ar.HKCUUser     = Convert.ToString(dr["HKCUUser"]);
                    ar.MachineID    = Convert.ToString(dr["MachineID"]);
                    ar.Username     = Convert.ToString(dr["Username"]);
                    ar.Item         = Convert.ToString(dr["Item"]);
                    ar.Key          = Convert.ToString(dr["Key"]);
                    ar.Location     = Convert.ToString(dr["Location"]);

                    StartupsRep.Items.Add(ar);
                }
                dr.Close();
            }

            return(RESTStatus.Success);
        }
Exemple #3
0
        public RESTStatus ListRKData(SQLLib sql, object dummy, NetworkConnectionInfo ni, string id)
        {
            if (ni.HasAcl(ACLFlags.ChangeServerSettings) == false)
            {
                ni.Error   = "Access denied";
                ni.ErrorID = ErrorFlags.AccessDenied;
                return(RESTStatus.Denied);
            }

            if (string.IsNullOrWhiteSpace(id) == true)
            {
                ni.Error   = "Invalid data";
                ni.ErrorID = ErrorFlags.InvalidData;
                return(RESTStatus.NotFound);
            }

            lock (ni.sqllock)
            {
                if (Computers.MachineExists(sql, id) == false)
                {
                    ni.Error   = "Invalid data";
                    ni.ErrorID = ErrorFlags.InvalidData;
                    return(RESTStatus.NotFound);
                }
            }

            LstRKData           = new BitlockerRKList();
            LstRKData.List      = new List <BitlockerRK>();
            LstRKData.MachineID = id;

            lock (ni.sqllock)
            {
                SqlDataReader dr = sql.ExecSQLReader("SELECT * FROM BitlockerRK WHERE MachineID=@m",
                                                     new SQLParam("@m", id));
                while (dr.Read())
                {
                    BitlockerRK rk = new BitlockerRK();
                    rk.DeviceID    = Convert.ToString(dr["DeviceID"]);
                    rk.DriveLetter = Convert.ToString(dr["DriveLetter"]);
                    rk.Reported    = SQLLib.GetDTUTC(dr["Reported"]);
                    rk.Keys        = JsonConvert.DeserializeObject <List <BitlockerRKKeyElement> >(Convert.ToString(dr["Keys"]));
                    LstRKData.List.Add(rk);
                }
                dr.Close();
            }

            return(RESTStatus.Success);
        }
Exemple #4
0
        static void PutComputerData(SqlDataReader dr, ref ComputerData cd)
        {
            cd.Comments                  = Convert.ToString(dr["Comments"]);
            cd.GroupingPath              = Convert.ToString(dr["Path"]);
            cd.Computername              = Convert.ToString(dr["ComputerName"]);
            cd.Approved                  = Convert.ToBoolean(dr["Accepted"]);
            cd.MachineID                 = Convert.ToString(dr["MachineID"]);
            cd.UCID                      = Convert.ToString(dr["UCID"]);
            cd.Make                      = Convert.ToString(dr["ComputerModel"]);
            cd.OS                        = Convert.ToString(dr["OSName"]);
            cd.OSVersion                 = Convert.ToString(dr["OSVerMaj"]) + "." + Convert.ToString(dr["OSVerMin"]) + "." + Convert.ToString(dr["OSVerBuild"]);
            cd.OSVerType                 = Convert.ToInt32(dr["OSVerType"]);
            cd.OSSuite                   = Convert.ToString(dr["OSSUite"]);
            cd.LastUpdated               = SQLLib.GetDTUTC(dr["LastUpdated"]);
            cd.CPU                       = Convert.ToString(dr["CPU"]);
            cd.Language                  = Convert.ToString(dr["Language"]) + " (" + Convert.ToString(dr["DisplayLanguage"]) + ")";
            cd.Is64Bit                   = Convert.ToBoolean(dr["Is64Bit"]);
            cd.IsTSE                     = Convert.ToBoolean(dr["IsTSE"]);
            cd.AgentVersion              = Convert.ToString(dr["AgentVersion"]);
            cd.AgentVersionID            = Convert.ToInt64(dr["AgentVersionID"]);
            cd.RunningInHypervisor       = Convert.ToBoolean(dr["RunningInHypervisor"]);
            cd.BIOS                      = Convert.ToString(dr["BIOS"]);
            cd.IPAddress                 = Convert.ToString(dr["IPAddress"]);
            cd.BIOSType                  = Convert.ToString(dr["BIOSType"]);
            cd.NumberOfLogicalProcessors = dr["NumberOfLogicalProcessors"] is DBNull ? 0 : Convert.ToInt32(dr["NumberOfLogicalProcessors"]);
            cd.NumberOfProcessors        = dr["NumberOfProcessors"] is DBNull ? 0 : Convert.ToInt32(dr["NumberOfProcessors"]);
            cd.TotalPhysicalMemory       = dr["TotalPhysicalMemory"] is DBNull ? 0L : Convert.ToInt64(dr["TotalPhysicalMemory"]);
            cd.CPUName                   = Convert.ToString(dr["CPUName"]);
            cd.SecureBootState           = Convert.ToString(dr["SecureBootState"]);
            cd.SystemRoot                = Convert.ToString(dr["SystemRoot"]);
            cd.SUSID                     = Convert.ToString(dr["SUSID"]);
            cd.RunningInWindowsPE        = dr["RunningInWindowsPE"] is DBNull ? (bool?)null : Convert.ToBoolean(dr["RunningInWindowsPE"]);
            cd.IsMeteredConnection       = dr["MeteredConnection"] is DBNull ? (bool?)null : Convert.ToBoolean(dr["MeteredConnection"]);

            if (Settings.Default.UseContract == true)
            {
                cd.ContractID = Convert.ToString(dr["ContractID"]);
            }
            else
            {
                cd.ContractID = "";
            }
        }
Exemple #5
0
        static PolicyObject LoadPolicyDB(SqlDataReader dr, bool withdata, bool CensorData)
        {
            PolicyObject po = new PolicyObject();

            if (withdata == false)
            {
                po.Data = null;
            }
            else
            {
                po.Data = Convert.ToString(dr["DataBlob"]);
            }
            po.DT        = SQLLib.GetDTUTC(dr["DT"]);
            po.Grouping  = dr["Grouping"] is DBNull ? (Int64?)null : Convert.ToInt64(dr["Grouping"]);
            po.ID        = Convert.ToInt64(dr["ID"]);
            po.MachineID = dr["MachineID"] is DBNull ? null : Convert.ToString(dr["MachineID"]);
            po.Name      = Convert.ToString(dr["Name"]);
            po.Version   = Convert.ToInt64(dr["Version"]);
            po.Enabled   = Convert.ToBoolean(dr["Enabled"]);
            po.Type      = Convert.ToInt32(dr["Type"]);

            if (CensorData == true && withdata == true)
            {
                if (po.Type == PolicyIDs.PortMapping)
                {
                    try
                    {
                        PortMappingPolicy p = JsonConvert.DeserializeObject <PortMappingPolicy>(po.Data);
                        p.ServerPort   = 0;
                        p.ServerServer = "";
                        po.Data        = JsonConvert.SerializeObject(p);
                    }
                    catch
                    {
                        po.Data = null;
                    }
                }
            }

            return(po);
        }
        public RESTStatus GetEventLogs(SQLLib sql, EventLogSearch eventlogsearch, NetworkConnectionInfo ni)
        {
            if (ni.HasAcl(ACLFlags.ChangeServerSettings) == false)
            {
                ni.Error   = "Access denied";
                ni.ErrorID = ErrorFlags.AccessDenied;
                return(RESTStatus.Denied);
            }

            EventLogs      = new EventLogReportFullList();
            EventLogs.Data = new List <EventLogReportFull>();

            if (eventlogsearch == null)
            {
                return(RESTStatus.Success);
            }

            if (eventlogsearch.QTY < 1)
            {
                eventlogsearch.QTY = 500;
            }

            string          SQLQuery     = "SELECT TOP " + eventlogsearch.QTY + " * FROM EventLog WHERE ";
            List <SQLParam> SQLQueryArgs = new List <SQLParam>();

            if (eventlogsearch.MachineID != null)
            {
                if (Computers.MachineExists(sql, eventlogsearch.MachineID) == false)
                {
                    ni.Error   = "Invalid Data";
                    ni.ErrorID = ErrorFlags.InvalidData;
                    return(RESTStatus.NotFound);
                }

                SQLQuery += "MachineID=@m AND ";
                SQLQueryArgs.Add(new SQLParam("@m", eventlogsearch.MachineID));
            }

            if (eventlogsearch.Source != null)
            {
                SQLQuery += "Source=@s AND ";
                SQLQueryArgs.Add(new SQLParam("@s", eventlogsearch.Source));
            }

            if (eventlogsearch.EventLogType != null)
            {
                SQLQuery += "EventLogType=@t AND ";
                SQLQueryArgs.Add(new SQLParam("@t", eventlogsearch.EventLogType));
            }

            if (eventlogsearch.FromDate != null)
            {
                SQLQuery += "TimeGenerated>=@tgf AND ";
                SQLQueryArgs.Add(new SQLParam("@tgf", eventlogsearch.FromDate));
            }

            if (eventlogsearch.ToDate != null)
            {
                SQLQuery += "TimeGenerated<=@tgt AND ";
                SQLQueryArgs.Add(new SQLParam("@tgt", eventlogsearch.ToDate));
            }

            if (eventlogsearch.EventLogBook != null)
            {
                SQLQuery += "EventLog=@evtb AND ";
                SQLQueryArgs.Add(new SQLParam("@evtb", eventlogsearch.EventLogBook));
            }

            if (eventlogsearch.CategoryNumber != null)
            {
                SQLQuery += "CategoryNumber=@catnum AND ";
                SQLQueryArgs.Add(new SQLParam("@catnum", eventlogsearch.CategoryNumber));
            }

            SQLQuery = SQLQuery.Trim();

            SQLQuery += "   1=1  ";

            SQLQuery += " ORDER BY TimeGenerated DESC";

            lock (ni.sqllock)
            {
                SqlDataReader dr = sql.ExecSQLReader(SQLQuery, SQLQueryArgs.ToArray());
                while (dr.Read())
                {
                    EventLogReportFull ev = new EventLogReportFull();
                    ev.Category               = Convert.ToString(dr["Category"]);
                    ev.CategoryNumber         = Convert.ToInt32(dr["CategoryNumber"]);
                    ev.Data                   = (byte[])dr["Data"];
                    ev.EventLog               = Convert.ToString(dr["EventLog"]);
                    ev.EventLogType           = Convert.ToInt32(dr["EventLogType"]);
                    ev.InstanceID             = Convert.ToInt64(dr["InstanceID"]);
                    ev.JSONReplacementStrings = Convert.ToString(dr["JSONReplacementStrings"]);
                    ev.LogID                  = Convert.ToString(dr["LogID"]);
                    ev.MachineID              = Convert.ToString(dr["MachineID"]);
                    ev.Message                = Convert.ToString(dr["Message"]);
                    ev.Reported               = SQLLib.GetDTUTC(dr["Reported"]);
                    ev.Source                 = Convert.ToString(dr["Source"]);
                    ev.TimeGenerated          = SQLLib.GetDTUTC(dr["TimeGenerated"]);
                    ev.TimeWritten            = SQLLib.GetDTUTC(dr["TimeWritten"]);
                    EventLogs.Data.Add(ev);
                }
                dr.Close();
            }

            return(RESTStatus.Success);
        }
        public RESTStatus GetAddRemovePrograms(SQLLib sql, object dummy, NetworkConnectionInfo ni, string id)
        {
            if (ni.HasAcl(ACLFlags.ChangeServerSettings) == false)
            {
                ni.Error   = "Access denied";
                ni.ErrorID = ErrorFlags.AccessDenied;
                return(RESTStatus.Denied);
            }

            AddRemoveRep       = new ListAddRemoveAppsReport();
            AddRemoveRep.Items = new List <AddRemoveAppReport>();

            lock (ni.sqllock)
            {
                SqlDataReader dr;
                if (string.IsNullOrWhiteSpace(id) == true)
                {
                    dr = sql.ExecSQLReader("select * from AddRemovePrograms inner join ComputerAccounts on ComputerAccounts.MachineID=AddRemovePrograms.MachineID left outer join UsersList on UsersList.SID=HKCUUser AND UsersList.MachineID=AddRemovePrograms.MachineID order by Name,VersionMajor,VersionMinor");
                }
                else
                {
                    if (Computers.MachineExists(sql, id) == false)
                    {
                        ni.Error   = "Invalid data";
                        ni.ErrorID = ErrorFlags.InvalidData;
                        return(RESTStatus.NotFound);
                    }

                    dr = sql.ExecSQLReader("select * from AddRemovePrograms inner join ComputerAccounts on ComputerAccounts.MachineID=AddRemovePrograms.MachineID left outer join UsersList on UsersList.SID=HKCUUser AND UsersList.MachineID=AddRemovePrograms.MachineID WHERE ComputerAccounts.MachineID=@m order by Name,VersionMajor,VersionMinor",
                                           new SQLParam("@m", id));
                }

                while (dr.Read())
                {
                    AddRemoveAppReport ar = new AddRemoveAppReport();
                    ar.Computername      = Convert.ToString(dr["Computername"]);
                    ar.DisplayLanguage   = Convert.ToString(dr["DisplayLanguage"]);
                    ar.DisplayVersion    = Convert.ToString(dr["DisplayVersion"]);
                    ar.IsMSI             = Convert.ToBoolean(dr["IsMSI"]);
                    ar.IsWOWBranch       = Convert.ToBoolean(dr["IsWOWBranch"]);
                    ar.IsSystemComponent = Convert.ToBoolean(dr["IsSystemComponent"]);
                    ar.Language          = Convert.ToString(dr["Language"]);
                    ar.MachineID         = Convert.ToString(dr["MachineID"]);
                    ar.Name            = Convert.ToString(dr["Name"]);
                    ar.ProductID       = Convert.ToString(dr["ProductID"]);
                    ar.UninstallString = Convert.ToString(dr["UninstallString"]);
                    ar.VersionMajor    = Convert.ToInt32(dr["VersionMajor"]);
                    ar.VersionMinor    = Convert.ToInt32(dr["VersionMinor"]);
                    ar.DT       = SQLLib.GetDTUTC(dr["DT"]);
                    ar.HKCUUser = Convert.ToString(dr["HKCUUser"]);
                    ar.Username = Convert.ToString(dr["Username"]);
                    if (string.IsNullOrWhiteSpace(ar.HKCUUser) == true)
                    {
                        ar.HKCUUser = "";
                    }

                    AddRemoveRep.Items.Add(ar);
                }
                dr.Close();
            }

            return(RESTStatus.Success);
        }
Exemple #8
0
        public RESTStatus ComputerLogin(SQLLib sql, ComputerLogon logon, NetworkConnectionInfo ni, string IPAddress)
        {
            Err = new ErrorInfo();

            if (logon == null)
            {
                Err.Error   = "Faulty data";
                Err.ErrorID = (int)ErrorFlags.FaultyData;
                return(RESTStatus.Fail);
            }

            if (NullTest.Test(logon) == false)
            {
                Err.Error   = "Invalid data";
                Err.ErrorID = (int)ErrorFlags.InvalidData;
                return(RESTStatus.Fail);
            }

            if (logon.SysInfo != null)
            {
                if (logon.SysInfo.BIOSType == null)
                {
                    logon.SysInfo.BIOSType = "N/A";
                }
                if (logon.SysInfo.CPUName == null)
                {
                    logon.SysInfo.CPUName = "N/A";
                }
                if (logon.SysInfo.SecureBootState == null)
                {
                    logon.SysInfo.SecureBootState = "N/A";
                }
                if (logon.SysInfo.ComputerModel == null)
                {
                    logon.SysInfo.ComputerModel = "N/A";
                }
                if (logon.SysInfo.ComputerModel.Trim() == "")
                {
                    logon.SysInfo.ComputerModel = "N/A";
                }
                if (logon.SysInfo.SystemRoot == null)
                {
                    logon.SysInfo.SystemRoot = "C:\\Windows";
                }
                if (logon.SysInfo.SUSID == null)
                {
                    logon.SysInfo.SUSID = "";
                }
                if (logon.SysInfo.SUSID.Trim() == "")
                {
                    logon.SysInfo.SUSID = Consts.NullGUID;
                }
                if (logon.SysInfo.LegacyUCID == null)
                {
                    logon.SysInfo.LegacyUCID = Consts.NullUCID;
                }
            }

            if (NullTest.Test(logon.SysInfo, "IsMeteredConnection", "RunningInWindowsPE") == false)
            {
                Err.Error   = "Invalid data";
                Err.ErrorID = (int)ErrorFlags.InvalidData;
                return(RESTStatus.Fail);
            }

            if (string.IsNullOrWhiteSpace(logon.Password) == true || string.IsNullOrWhiteSpace(logon.Username) == true)
            {
                Err.Error   = "Invalid data";
                Err.ErrorID = (int)ErrorFlags.InvalidData;
                return(RESTStatus.Fail);
            }

            if (NullTest.TestBlankString(logon.SysInfo, "IsMeteredConnection", "RunningInWindowsPE") == false)
            {
                Err.Error   = "Invalid data";
                Err.ErrorID = (int)ErrorFlags.InvalidData;
                return(RESTStatus.Fail);
            }

            Guid testguid;

            if (Guid.TryParse(logon.Username, out testguid) == false)
            {
                Err.Error   = "Invalid username";
                Err.ErrorID = (int)ErrorFlags.InvalidUsername;
                return(RESTStatus.Fail);
            }

            if (Guid.TryParse(logon.Password, out testguid) == false)
            {
                Err.Error   = "Invalid password";
                Err.ErrorID = (int)ErrorFlags.InvalidPassword;
                return(RESTStatus.Fail);
            }

            if (logon.SysInfo.UCID.Trim().Length != 32)
            {
                Err.Error   = "Invalid UCID";
                Err.ErrorID = (int)ErrorFlags.InvalidValue;
                return(RESTStatus.Fail);
            }

            if (logon.ContractID == null)
            {
                logon.ContractID = "";
            }
            if (logon.ContractPassword == null)
            {
                logon.ContractPassword = "";
            }

            if (Fox_LicenseGenerator.SDCLicensing.ValidLicense == false)
            {
                FoxEventLog.WriteEventLog("Licensing error: no valid license found. Client login are rejected.", EventLogEntryType.Warning);
                Err.Error   = "Licensing error";
                Err.ErrorID = (int)ErrorFlags.LicensingError;
                return(RESTStatus.Fail);
            }

            if (Fox_LicenseGenerator.SDCLicensing.TestExpiry() == false)
            {
                FoxEventLog.WriteEventLog("Licensing error: license expired. Client login are rejected.", EventLogEntryType.Warning);
                Err.Error   = "Licensing error";
                Err.ErrorID = (int)ErrorFlags.LicensingError;
                return(RESTStatus.Fail);
            }

            if (Settings.Default.UseContract == true)
            {
                if (logon.ContractID == "")
                {
                    Err.Error   = "Invalid Contract Data";
                    Err.ErrorID = (int)ErrorFlags.FaultyContractData;
                    return(RESTStatus.Fail);
                }
                if (logon.ContractPassword == "")
                {
                    Err.Error   = "Invalid Contract Data";
                    Err.ErrorID = (int)ErrorFlags.FaultyContractData;
                    return(RESTStatus.Fail);
                }
            }

            logon.Username          = logon.Username.Trim().ToUpper();
            logon.SysInfo.MachineID = logon.SysInfo.MachineID.Trim().ToUpper();

            if (logon.Username != logon.SysInfo.MachineID)
            {
                Err.Error   = "Invalid Username/MachineID";
                Err.ErrorID = (int)ErrorFlags.InvalidValue;
                return(RESTStatus.Fail);
            }

            string newID = NetworkConnection.NewSession();

            ni = NetworkConnection.GetSession(newID);
            if (NetworkConnectionProcessor.InitNi(ni) == false)
            {
                NetworkConnection.DeleteSession(newID);
                Err.Error   = "System Error";
                Err.ErrorID = (int)ErrorFlags.SystemError;
                return(RESTStatus.ServerError);
            }
            sql = ni.sql;

            ni.Permissions = 0;
            ni.Error       = "";
            ni.ErrorID     = ErrorFlags.NoError;

            if (Fox_LicenseGenerator.SDCLicensing.NumComputers != null)
            {
                Int64 Computers = Convert.ToInt64(sql.ExecSQLScalar("select count(*) from ComputerAccounts where Accepted=1"));
                if (Computers > Fox_LicenseGenerator.SDCLicensing.NumComputers.Value)
                {
                    NetworkConnection.DeleteSession(newID);
                    FoxEventLog.WriteEventLog("Licensing error: too many computers are accepted. Client login are rejected.\n" +
                                              "Lic=" + Fox_LicenseGenerator.SDCLicensing.NumComputers.Value.ToString() + " Listed=" + Computers.ToString(),
                                              EventLogEntryType.Warning);
                    Err.Error   = "Licensing error";
                    Err.ErrorID = (int)ErrorFlags.LicensingError;
                    return(RESTStatus.Fail);
                }
            }

            if (Settings.Default.UseContract == true)
            {
                if (Convert.ToInt32(sql.ExecSQLScalar("SELECT Count(*) FROM Contracts WHERE ContractID=@id AND ContractPassword=@pw AND Disabled=0",
                                                      new SQLParam("@id", logon.ContractID),
                                                      new SQLParam("@pw", logon.ContractPassword))) == 0)
                {
                    NetworkConnection.DeleteSession(newID);
                    Err.Error   = "Invalid/Disabled Contract Data";
                    Err.ErrorID = (int)ErrorFlags.FaultyContractData;
                    return(RESTStatus.Fail);
                }
            }

            if (Convert.ToInt32(sql.ExecSQLScalar("SELECT COUNT(*) FROM ComputerAccounts WHERE MachineID=@m",
                                                  new SQLParam("@m", logon.Username))) == 0)
            {
                if (Convert.ToInt32(sql.ExecSQLScalar("SELECT COUNT(*) FROM ComputerAccounts WHERE UCID=@u",
                                                      new SQLParam("@u", logon.SysInfo.UCID.Trim()))) > 0)
                {
                    NetworkConnection.DeleteSession(newID);
                    Err.Error   = "UCID used for a different machine";
                    Err.ErrorID = (int)ErrorFlags.UCIDissues;
                    return(RESTStatus.Fail);
                }

                if (Settings.Default.UseContract == true)
                {
                    object o = sql.ExecSQLScalar("Select MaxComputers FROM Contracts WHERE ContractID=@cid", new SQLParam("@cid", logon.ContractID));
                    if (!(o is DBNull))
                    {
                        int i;
                        if (int.TryParse(o.ToString(), out i) == true)
                        {
                            int cnt = Convert.ToInt32(sql.ExecSQL("Select count(*) FROM ComputerAccounts WHERE ContractID=@cid", new SQLParam("@cid", logon.ContractID)));
                            if (cnt + 1 > i)
                            {
                                NetworkConnection.DeleteSession(newID);
                                Err.Error   = "Number of computers exhausted";
                                Err.ErrorID = (int)ErrorFlags.ContractNumComputersExhausted;
                                return(RESTStatus.Fail);
                            }
                        }
                    }
                }

                sql.InsertMultiData("ComputerAccounts",
                                    new SQLData("MachineID", logon.SysInfo.MachineID),
                                    new SQLData("UCID", logon.SysInfo.UCID),
                                    new SQLData("Password", logon.Password),
                                    new SQLData("Is64Bit", logon.SysInfo.Is64Bit),
                                    new SQLData("OSName", logon.SysInfo.OSName),
                                    new SQLData("OSVerMaj", logon.SysInfo.OSVerMaj),
                                    new SQLData("OSVerMin", logon.SysInfo.OSVerMin),
                                    new SQLData("OSVerBuild", logon.SysInfo.OSVerBuild),
                                    new SQLData("OSSuite", logon.SysInfo.OSSuite),
                                    new SQLData("IsTSE", logon.SysInfo.IsTSE),
                                    new SQLData("CPU", logon.SysInfo.CPU),
                                    new SQLData("ComputerModel", logon.SysInfo.ComputerModel),
                                    new SQLData("ComputerName", logon.SysInfo.ComputerName),
                                    new SQLData("Language", logon.SysInfo.Language),
                                    new SQLData("DisplayLanguage", logon.SysInfo.DisplayLanguage),
                                    new SQLData("AgentVersion", logon.SysInfo.AgentVersion),
                                    new SQLData("AgentVersionID", logon.SysInfo.AgentVersionID),
                                    new SQLData("OSVerType", logon.SysInfo.OSVerType),
                                    new SQLData("RunningInHypervisor", logon.SysInfo.RunningInHypervisor),
                                    new SQLData("BIOS", logon.SysInfo.BIOS),
                                    new SQLData("BIOSType", logon.SysInfo.BIOSType),
                                    new SQLData("NumberOfLogicalProcessors", logon.SysInfo.NumberOfLogicalProcessors),
                                    new SQLData("NumberOfProcessors", logon.SysInfo.NumberOfProcessors),
                                    new SQLData("TotalPhysicalMemory", logon.SysInfo.TotalPhysicalMemory),
                                    new SQLData("CPUName", logon.SysInfo.CPUName),
                                    new SQLData("SecureBootState", logon.SysInfo.SecureBootState),
                                    new SQLData("IPAddress", IPAddress),
                                    new SQLData("SystemRoot", logon.SysInfo.SystemRoot),
                                    new SQLData("SUSID", logon.SysInfo.SUSID),
                                    new SQLData("MeteredConnection", logon.SysInfo.IsMeteredConnection),
                                    new SQLData("RunningInWindowsPE", logon.SysInfo.RunningInWindowsPE),
                                    new SQLData("ContractID", Settings.Default.UseContract == true ? (object)logon.ContractID : DBNull.Value));

                Err.Error   = "Not accepted (computer registered)";
                Err.ErrorID = (int)ErrorFlags.NotAccepted;
                NetworkConnection.DeleteSession(newID);
                return(RESTStatus.Fail);
            }

            if (Convert.ToInt32(sql.ExecSQLScalar("SELECT COUNT(*) FROM ComputerAccounts WHERE MachineID=@m AND UCID=@ucid",
                                                  new SQLParam("@m", logon.Username),
                                                  new SQLParam("@ucid", logon.SysInfo.UCID.Trim()))) == 0)
            {
                #region Remove in future
                if (logon.SysInfo.LegacyUCID != Consts.NullUCID && logon.SysInfo.LegacyUCID.Trim().Length == 32)
                {
                    if (Convert.ToInt32(sql.ExecSQLScalar("SELECT COUNT(*) FROM ComputerAccounts WHERE UCID=@u AND MachineID=@m AND Password=@p",
                                                          new SQLParam("@u", logon.SysInfo.LegacyUCID.Trim()),
                                                          new SQLParam("@p", logon.Password),
                                                          new SQLParam("@m", logon.Username))) > 0)
                    {
                        sql.ExecSQL("UPDATE ComputerAccounts SET UCID=@nu WHERE UCID=@u AND MachineID=@m",
                                    new SQLParam("@nu", logon.SysInfo.UCID.Trim()),
                                    new SQLParam("@u", logon.SysInfo.LegacyUCID.Trim()),
                                    new SQLParam("@m", logon.Username));

                        FoxEventLog.WriteEventLog("UCID changed:\nMachineID: " + logon.Username + "\nName: " + logon.SysInfo.ComputerName + "\nLUCID: " + logon.SysInfo.LegacyUCID + "\nUCID: " + logon.SysInfo.UCID, EventLogEntryType.Warning);

                        Err.Error   = "UCID changed!";
                        Err.ErrorID = (int)ErrorFlags.NotAccepted;
                        NetworkConnection.DeleteSession(newID);
                        return(RESTStatus.Fail);
                    }
                }
                #endregion

                Err.Error   = "MachineID & UCID do not match";
                Err.ErrorID = (int)ErrorFlags.MachineUCIDmissmatch;
                NetworkConnection.DeleteSession(newID);
                return(RESTStatus.Fail);
            }

            if (Convert.ToInt32(sql.ExecSQLScalar("SELECT COUNT(*) FROM ComputerAccounts WHERE MachineID=@m AND Password=@p",
                                                  new SQLParam("@m", logon.Username),
                                                  new SQLParam("@p", logon.Password))) == 0)
            {
                Err.Error   = "Invalid password";
                Err.ErrorID = (int)ErrorFlags.InvalidPassword;
                NetworkConnection.DeleteSession(newID);
                return(RESTStatus.Fail);
            }

            if (Settings.Default.UseContract == true)
            {
                string CurrentContractID = Convert.ToString(sql.ExecSQLScalar("SELECT ContractID FROM ComputerAccounts WHERE MachineID=@m",
                                                                              new SQLParam("@m", logon.Username)));
                if (CurrentContractID == null)
                {
                    CurrentContractID = "";
                }
                if (CurrentContractID != "")
                {
                    if (CurrentContractID.Trim().ToLower() != logon.ContractID.Trim().ToLower())
                    {
                        Err.Error   = "Invalid Contract Data";
                        Err.ErrorID = (int)ErrorFlags.FaultyContractData;
                        NetworkConnection.DeleteSession(newID);
                        return(RESTStatus.Fail);
                    }
                }

                object   dt;
                DateTime dtt;

                dt = sql.ExecSQLScalar("Select ValidFrom FROM Contracts WHERE ContractID=@cid", new SQLParam("@cid", CurrentContractID));
                if (!(dt is DBNull))
                {
                    try
                    {
                        dtt = SQLLib.GetDTUTC(dt);
                        if (DateTime.UtcNow < dtt)
                        {
                            Err.Error   = "Contract not started / expired";
                            Err.ErrorID = (int)ErrorFlags.ContractNotStarted_Expired;
                            NetworkConnection.DeleteSession(newID);
                            return(RESTStatus.Fail);
                        }
                    }
                    catch
                    {
                        Err.Error   = "Invalid Contract Data";
                        Err.ErrorID = (int)ErrorFlags.FaultyContractData;
                        NetworkConnection.DeleteSession(newID);
                        return(RESTStatus.Fail);
                    }
                }

                dt = sql.ExecSQLScalar("Select ValidTo FROM Contracts WHERE ContractID=@cid", new SQLParam("@cid", CurrentContractID));
                if (!(dt is DBNull))
                {
                    try
                    {
                        dtt = SQLLib.GetDTUTC(dt);
                        if (dtt < DateTime.UtcNow)
                        {
                            Err.Error   = "Contract not started / expired";
                            Err.ErrorID = (int)ErrorFlags.ContractNotStarted_Expired;
                            NetworkConnection.DeleteSession(newID);
                            return(RESTStatus.Fail);
                        }
                    }
                    catch
                    {
                        Err.Error   = "Invalid Contract Data";
                        Err.ErrorID = (int)ErrorFlags.FaultyContractData;
                        NetworkConnection.DeleteSession(newID);
                        return(RESTStatus.Fail);
                    }
                }
            }
            else
            {
                logon.ContractID       = "";
                logon.ContractPassword = "";
            }

            sql.ExecSQL("UPDATE ComputerAccounts SET BIOS=@BIOS, OSVerType=@OSVerType, Is64Bit = @Is64Bit,OSName = @OSName,OSVerMaj = @OSVerMaj," +
                        "OSVerMin = @OSVerMin,OSVerBuild = @OSVerBuild,OSSuite = @OSSuite,IsTSE = @IsTSE,CPU = @CPU,ComputerModel = @ComputerModel,ComputerName = @ComputerName," +
                        "Language = @Language,DisplayLanguage = @DisplayLanguage,MachineID = @MachineID,LastUpdated = getutcdate(), AgentVersion=@AgentVersion, AgentVersionID=@AgentVersionID," +
                        "RunningInHypervisor=@RunningInHypervisor, ContractID=@ContractID, IPAddress=@IPAddress,BIOSType=@BIOSType, NumberOfLogicalProcessors=@NumberOfLogicalProcessors, " +
                        "NumberOfProcessors=@NumberOfProcessors, TotalPhysicalMemory=@TotalPhysicalMemory, CPUName=@CPUName, SecureBootState=@SecureBootState, " +
                        "SystemRoot=@SystemRoot,SUSID=@SUSID,MeteredConnection=@meteredconnection, " +
                        "RunningInWindowsPE=@RunningInWindowsPE " +
                        "    WHERE MachineID = @MachineID",
                        new SQLParam("@Is64Bit", logon.SysInfo.Is64Bit),
                        new SQLParam("@OSName", logon.SysInfo.OSName),
                        new SQLParam("@OSVerMaj", logon.SysInfo.OSVerMaj),
                        new SQLParam("@OSVerMin", logon.SysInfo.OSVerMin),
                        new SQLParam("@OSVerBuild", logon.SysInfo.OSVerBuild),
                        new SQLParam("@OSSuite", logon.SysInfo.OSSuite),
                        new SQLParam("@IsTSE", logon.SysInfo.IsTSE),
                        new SQLParam("@CPU", logon.SysInfo.CPU),
                        new SQLParam("@ComputerModel", logon.SysInfo.ComputerModel),
                        new SQLParam("@ComputerName", logon.SysInfo.ComputerName),
                        new SQLParam("@Language", logon.SysInfo.Language),
                        new SQLParam("@DisplayLanguage", logon.SysInfo.DisplayLanguage),
                        new SQLParam("@MachineID", logon.Username),
                        new SQLParam("@AgentVersionID", logon.SysInfo.AgentVersionID),
                        new SQLParam("@AgentVersion", logon.SysInfo.AgentVersion),
                        new SQLParam("@OSVerType", logon.SysInfo.OSVerType),
                        new SQLParam("@RunningInHypervisor", logon.SysInfo.RunningInHypervisor),
                        new SQLParam("@BIOS", logon.SysInfo.BIOS),
                        new SQLParam("@BIOSType", logon.SysInfo.BIOSType),
                        new SQLParam("@NumberOfLogicalProcessors", logon.SysInfo.NumberOfLogicalProcessors),
                        new SQLParam("@NumberOfProcessors", logon.SysInfo.NumberOfProcessors),
                        new SQLParam("@TotalPhysicalMemory", logon.SysInfo.TotalPhysicalMemory),
                        new SQLParam("@CPUName", logon.SysInfo.CPUName),
                        new SQLParam("@SecureBootState", logon.SysInfo.SecureBootState),
                        new SQLParam("@IPAddress", IPAddress),
                        new SQLParam("@SystemRoot", logon.SysInfo.SystemRoot),
                        new SQLParam("@SUSID", logon.SysInfo.SUSID),
                        new SQLParam("@meteredconnection", logon.SysInfo.IsMeteredConnection),
                        new SQLParam("@RunningInWindowsPE", logon.SysInfo.RunningInWindowsPE),
                        new SQLParam("@ContractID", Settings.Default.UseContract == true ? (object)logon.ContractID : DBNull.Value));

            sql.ExecSQL("UPDATE ComputerAccounts SET LastUpdated=getutcdate() WHERE MachineID=@m",
                        new SQLParam("@m", logon.Username));

            int Acceptance = Convert.ToInt32(sql.ExecSQLScalar("SELECT Accepted FROM ComputerAccounts WHERE MachineID=@m",
                                                               new SQLParam("@m", logon.Username)));

            switch (Acceptance)
            {
            case 1:     //OK
                break;

            default:
                Err.Error   = "Not accepted";
                Err.ErrorID = (int)ErrorFlags.NotAccepted;
                NetworkConnection.DeleteSession(newID);
                return(RESTStatus.Fail);
            }

            ni.Username           = logon.Username;
            ni.Name               = logon.SysInfo.ComputerName;
            ni.EMail              = "";
            ni.MustChangePassword = false;
            ni.LoggedIn           = false;
            ni.ComputerLoggedIn   = true;
            ni.Permissions        = (Int64)ACLFlags.ComputerLogin;
            Debug.WriteLine("Computer: " + ni.Name + " logged in");
            Err.Error   = "OK:" + newID;
            Err.ErrorID = (int)ErrorFlags.NoError;
            return(RESTStatus.Success);
        }
Exemple #9
0
        public List <ReportingPaperElements> GetItems(string MachineID, DateTime?From, DateTime?To, int ReportingPaper)
        {
            List <ReportingPaperElements> lst = new List <ReportingPaperElements>();

            if (string.IsNullOrWhiteSpace(MachineID) == true)
            {
                ReportingPaperElements funnybasicinfo = new ReportingPaperElements();
                funnybasicinfo.AgentVersion        = "Fox SDC 950228180442";
                funnybasicinfo.BIOSBootType        = "Legacy";
                funnybasicinfo.LastUpdated         = new DateTime(1995, 3, 5, 19, 35, 21);
                funnybasicinfo.MachineID           = "8878FF7A-2506-4A63-B0F1-A0C28AFD6480";
                funnybasicinfo.MachineName         = "FOX-PC1-NT3";
                funnybasicinfo.OS                  = "Windows NT 3.51 Service Pack 5";
                funnybasicinfo.OSVersion           = "3.51.1057";
                funnybasicinfo.OSWin10Version      = "";
                funnybasicinfo.TotalPhysicalMemory = CommonUtilities.NiceSize(67108864);
                funnybasicinfo.UCID                = "F3489E4C92654D12A6EF6C4C2EAA4A5E";
                funnybasicinfo.VendorBIOS          = "Award BIOS 6";
                funnybasicinfo.VendorMake          = "Vulpes 486 PC";
                funnybasicinfo.ContractID          = "Company XXX Contract";

                lst.Add(new ReportingPaperElements());
                CopyBaseData(funnybasicinfo, lst[0]);
                lst[0].ID            = 10005;
                lst[0].ReportedDate  = new DateTime(1995, 3, 5, 18, 20, 54);
                lst[0].IconPicture   = Resources.Vulpes.ToBitmap();
                lst[0].StatusPicture = ReportingStatusPicture.GetPicture(ReportingStatusPictureEnum.Good);
                lst[0].Text          = "Reporting test ...\nNew line\n\nAnother line";

                lst.Add(new ReportingPaperElements());
                CopyBaseData(funnybasicinfo, lst[1]);
                lst[1].ID            = 10004;
                lst[1].ReportedDate  = new DateTime(1995, 3, 5, 18, 19, 12);
                lst[1].IconPicture   = Resources.EventLog.ToBitmap();
                lst[1].StatusPicture = ReportingStatusPicture.GetPicture(ReportingStatusPictureEnum.Info);
                lst[1].Text          = "The Event log service was started.";

                lst.Add(new ReportingPaperElements());
                CopyBaseData(funnybasicinfo, lst[2]);
                lst[2].ID            = 10003;
                lst[2].ReportedDate  = new DateTime(1995, 3, 5, 18, 15, 35);
                lst[2].IconPicture   = Resources.EventLog.ToBitmap();
                lst[2].StatusPicture = ReportingStatusPicture.GetPicture(ReportingStatusPictureEnum.Stop);
                lst[2].Text          = "The system has rebooted without cleanly shutting down first. This error could be caused if the system stopped responding, crashed, or lost power unexpectedly.";

                return(lst);
            }

            Settings.Default.Load();

            using (SQLLib sql = SQLTest.ConnectSQL("Fox SDC Server for Reporting"))
            {
                if (sql == null)
                {
                    return(lst);
                }

                //Get some ComputerInfo
                SqlDataReader dr = sql.ExecSQLReader("select * from ComputerAccounts Where MachineID=@m",
                                                     new SQLParam("@m", MachineID));
                if (dr.HasRows == false)
                {
                    dr.Close();
                    sql.CloseConnection();
                    return(lst);
                }

                dr.Read();
                ReportingPaperElements basicinfo = new ReportingPaperElements();
                basicinfo.AgentVersion        = Convert.ToString(dr["AgentVersion"]);
                basicinfo.BIOSBootType        = Convert.ToString(dr["BIOSType"]);
                basicinfo.LastUpdated         = SQLLib.GetDTUTC(dr["LastUpdated"]);
                basicinfo.MachineID           = Convert.ToString(dr["MachineID"]);
                basicinfo.MachineName         = Convert.ToString(dr["ComputerName"]);
                basicinfo.OS                  = Convert.ToString(dr["OSName"]);
                basicinfo.OSVersion           = Convert.ToString(dr["OSVerMaj"]) + "." + Convert.ToString(dr["OSVerMin"]) + "." + Convert.ToString(dr["OSVerBuild"]);
                basicinfo.OSWin10Version      = Win10Version.GetWin10Version(basicinfo.OSVersion);
                basicinfo.TotalPhysicalMemory = CommonUtilities.NiceSize(Convert.ToInt64(dr["TotalPhysicalMemory"]));
                basicinfo.UCID                = Convert.ToString(dr["UCID"]);
                basicinfo.VendorBIOS          = Convert.ToString(dr["BIOS"]);
                basicinfo.VendorMake          = Convert.ToString(dr["ComputerModel"]);
                basicinfo.ContractID          = Convert.ToString(dr["ContractID"]);
                dr.Close();

                string          Query     = "";
                List <SQLParam> SQLParams = new List <SQLParam>();
                switch ((ReportingFlagsPaper)ReportingPaper)
                {
                case ReportingFlagsPaper.UrgentAdmin:
                    Query = "Select * from Reporting where machineid=@mid and (Flags & @f1)!=0 AND (Flags & @f2)=0 order by Reported desc";
                    SQLParams.Add(new SQLParam("@mid", MachineID));
                    SQLParams.Add(new SQLParam("@f1", ReportingFlags.UrgentForAdmin));
                    SQLParams.Add(new SQLParam("@f2", ReportingFlags.UrgentAdminReported));
                    break;

                case ReportingFlagsPaper.UrgentClient:
                    Query = "Select * from Reporting where machineid=@mid and (Flags & @f1)!=0 AND (Flags & @f2)=0 order by Reported desc";
                    SQLParams.Add(new SQLParam("@mid", MachineID));
                    SQLParams.Add(new SQLParam("@f1", ReportingFlags.UrgentForClient));
                    SQLParams.Add(new SQLParam("@f2", ReportingFlags.UrgentClientReported));
                    break;

                case ReportingFlagsPaper.ReportAdmin:
                    Query = "Select * from Reporting where machineid=@mid and (Flags & @f1)!=0 AND (Flags & @f2)=0 order by Reported desc";
                    SQLParams.Add(new SQLParam("@mid", MachineID));
                    SQLParams.Add(new SQLParam("@f1", ReportingFlags.ReportToAdmin));
                    SQLParams.Add(new SQLParam("@f2", ReportingFlags.AdminReported));
                    break;

                case ReportingFlagsPaper.ReportClient:
                    Query = "Select * from Reporting where machineid=@mid and (Flags & @f1)!=0 AND (Flags & @f2)=0 order by Reported desc";
                    SQLParams.Add(new SQLParam("@mid", MachineID));
                    SQLParams.Add(new SQLParam("@f1", ReportingFlags.ReportToClient));
                    SQLParams.Add(new SQLParam("@f2", ReportingFlags.ClientReported));
                    break;

                case ReportingFlagsPaper.ReReport:
                    if (From == null && To == null)
                    {
                        Query = "Select * from Reporting where machineid=@mid order by Reported desc";
                        SQLParams.Add(new SQLParam("@mid", MachineID));
                    }
                    if (From != null && To == null)
                    {
                        Query = "Select * from Reporting where machineid=@mid AND Reported>=@d1 order by Reported desc";
                        SQLParams.Add(new SQLParam("@mid", MachineID));
                        SQLParams.Add(new SQLParam("@d1", From.Value));
                    }
                    if (From == null && To != null)
                    {
                        Query = "Select * from Reporting where machineid=@mid AND Reported<=@d1 order by Reported desc";
                        SQLParams.Add(new SQLParam("@mid", MachineID));
                        SQLParams.Add(new SQLParam("@d1", To.Value));
                    }
                    if (From != null && To != null)
                    {
                        Query = "Select * from Reporting where machineid=@mid and Reported between @d1 and @d2 order by Reported desc";
                        SQLParams.Add(new SQLParam("@mid", MachineID));
                        SQLParams.Add(new SQLParam("@d1", From.Value));
                        SQLParams.Add(new SQLParam("@d2", To.Value));
                    }
                    break;

                default:
                    return(lst);
                }

                List <Int64> ReportedIDs = new List <long>();

                dr = sql.ExecSQLReader(Query, SQLParams.ToArray());
                while (dr.Read())
                {
                    ReportingPaperElements r = new ReportingPaperElements();
                    CopyBaseData(basicinfo, r);
                    ReportedIDs.Add(Convert.ToInt64(dr["ID"]));
                    r.ID            = Convert.ToInt64(dr["ID"]);
                    r.Flags         = Convert.ToInt64(dr["Flags"]);
                    r.ReportingType = Convert.ToInt32(dr["Type"]);
                    r.ReportedDate  = SQLLib.GetDTUTC(dr["Reported"]);
                    r.StatusPicture = ReportingStatusPicture.GetPicture((int)((r.Flags & (Int64)ReportingFlags.IconFlags) >> (int)ReportingFlags.IconFlagsShift));
                    IReportingExplain explain = ReportingProcessor.FindExplainer(r.ReportingType);
                    if (explain != null)
                    {
                        r.Text        = explain.Explain(Convert.ToString(dr["Data"]));
                        r.IconPicture = explain.GetIcon();
                    }
                    else
                    {
                        r.Text        = "Missing module for Type=" + r.ReportingType.ToString() + "; Text=" + Convert.ToString(dr["Data"]);
                        r.IconPicture = Resources.Nix.ToBitmap();
                    }
                    lst.Add(r);
                }
                dr.Close();

                if (ReportedIDs.Count > 0 && (ReportingFlagsPaper)ReportingPaper != ReportingFlagsPaper.ReReport)
                {
                    string SQLIn = "";
                    foreach (Int64 i in ReportedIDs)
                    {
                        SQLIn += i.ToString() + ",";
                    }

                    if (SQLIn.EndsWith(",") == true)
                    {
                        SQLIn = SQLIn.Substring(0, SQLIn.Length - 1);
                    }

                    Query     = "";
                    SQLParams = new List <SQLParam>();

                    switch ((ReportingFlagsPaper)ReportingPaper)
                    {
                    case ReportingFlagsPaper.UrgentAdmin:
                        Query = "update Reporting set Flags = Flags | @f2 where machineid=@mid and Flags & @f1!=0 AND Flags & @f2=0";
                        SQLParams.Add(new SQLParam("@mid", MachineID));
                        SQLParams.Add(new SQLParam("@f1", ReportingFlags.UrgentForAdmin));
                        SQLParams.Add(new SQLParam("@f2", ReportingFlags.UrgentAdminReported));
                        break;

                    case ReportingFlagsPaper.UrgentClient:
                        Query = "update Reporting set Flags = Flags | @f2 where machineid=@mid and Flags & @f1!=0 AND Flags & @f2=0";
                        SQLParams.Add(new SQLParam("@mid", MachineID));
                        SQLParams.Add(new SQLParam("@f1", ReportingFlags.UrgentForClient));
                        SQLParams.Add(new SQLParam("@f2", ReportingFlags.UrgentClientReported));
                        break;

                    case ReportingFlagsPaper.ReportAdmin:
                        Query = "update Reporting set Flags = Flags | @f2 where machineid=@mid and Flags & @f1!=0 AND Flags & @f2=0";
                        SQLParams.Add(new SQLParam("@mid", MachineID));
                        SQLParams.Add(new SQLParam("@f1", ReportingFlags.ReportToAdmin));
                        SQLParams.Add(new SQLParam("@f2", ReportingFlags.AdminReported));
                        break;

                    case ReportingFlagsPaper.ReportClient:
                        Query = "update Reporting set Flags = Flags | @f2 where machineid=@mid and Flags & @f1!=0 AND Flags & @f2=0";
                        SQLParams.Add(new SQLParam("@mid", MachineID));
                        SQLParams.Add(new SQLParam("@f1", ReportingFlags.ReportToClient));
                        SQLParams.Add(new SQLParam("@f2", ReportingFlags.ClientReported));
                        break;
                    }

                    sql.ExecSQLNQ(Query, SQLParams.ToArray());
                }
            }
            return(lst);
        }
Exemple #10
0
        public RESTStatus ListDevicesData(SQLLib sql, object dummy, NetworkConnectionInfo ni, string id)
        {
            if (ni.HasAcl(ACLFlags.ChangeServerSettings) == false)
            {
                ni.Error   = "Access denied";
                ni.ErrorID = ErrorFlags.AccessDenied;
                return(RESTStatus.Denied);
            }

            if (string.IsNullOrWhiteSpace(id) == true)
            {
                ni.Error   = "Invalid data";
                ni.ErrorID = ErrorFlags.InvalidData;
                return(RESTStatus.NotFound);
            }

            lock (ni.sqllock)
            {
                if (Computers.MachineExists(sql, id) == false)
                {
                    ni.Error   = "Invalid data";
                    ni.ErrorID = ErrorFlags.InvalidData;
                    return(RESTStatus.NotFound);
                }
            }

            LstDevData           = new PnPDeviceList();
            LstDevData.List      = new List <PnPDevice>();
            LstDevData.MachineID = id;

            lock (ni.sqllock)
            {
                SqlDataReader dr = sql.ExecSQLReader("SELECT * FROM DevicesConfig WHERE MachineID=@mid", new SQLParam("@mid", id));
                while (dr.Read())
                {
                    PnPDevice n = new PnPDevice();
                    n.Availability            = Convert.ToInt32(dr["Availability"]);
                    n.Caption                 = Convert.ToString(dr["Caption"]);
                    n.ClassGuid               = Convert.ToString(dr["ClassGuid"]);
                    n.ConfigManagerErrorCode  = Convert.ToInt32(dr["ConfigManagerErrorCode"]);
                    n.ConfigManagerUserConfig = Convert.ToBoolean(dr["ConfigManagerUserConfig"]);
                    n.CreationClassName       = Convert.ToString(dr["CreationClassName"]);
                    n.Description             = Convert.ToString(dr["Description"]);
                    n.ErrorCleared            = dr["ErrorCleared"] is DBNull ? (bool?)null : Convert.ToBoolean(dr["ErrorCleared"]);
                    n.ErrorDescription        = Convert.ToString(dr["ErrorDescription"]);
                    n.Index         = Convert.ToInt32(dr["Index"]);
                    n.InstallDate   = dr["InstallDate"] is DBNull ? (DateTime?)null : SQLLib.GetDTUTC(dr["InstallDate"]);
                    n.LastErrorCode = dr["LastErrorCode"] is DBNull ? (int?)null : Convert.ToInt32(dr["LastErrorCode"]);
                    n.Manufacturer  = Convert.ToString(dr["Manufacturer"]);
                    n.Name          = Convert.ToString(dr["Name"]);
                    n.PNPClass      = Convert.ToString(dr["PNPClass"]);
                    n.PNPDeviceID   = Convert.ToString(dr["PNPDeviceID"]);
                    n.Present       = Convert.ToBoolean(dr["Present"]);
                    n.Service       = Convert.ToString(dr["Service"]);
                    n.Status        = Convert.ToString(dr["Status"]);
                    n.StatusInfo    = dr["StatusInfo"] is DBNull ? (int?)null : Convert.ToInt32(dr["StatusInfo"]);
                    n.HardwareID    = JsonConvert.DeserializeObject <List <string> >(Convert.ToString(dr["HardwareID"]));
                    n.CompatibleID  = JsonConvert.DeserializeObject <List <string> >(Convert.ToString(dr["CompatibleID"]));
                    LstDevData.List.Add(n);
                }
                dr.Close();
            }

            return(RESTStatus.Success);
        }