Set LogonHours Active Directory

[julierme]

Dear,
I'm developing a system to restrict user login times in AD, I can view login times and even change. But for example, I'm not able to establish this login time from 17:00 to midnight, the system appears to be zero, another issue is to establish the time from 00:00 to 00:00, when this done in the system in AD, it displays as denied.

I'm using as a base the classes available here: LogonTime.cs
Observe the days of Friday and Saturday, the system is showing up empty, but in AD is marked the allowed times.
I need help getting these details right.

 

[julierme]

The difficulty is to set the time allowed, for example, from 17:00 to midnight and also set the permission for the whole day. e.g.: 00:00 to 00:00 (midnight)
And display these results in the combobox

PermittedLogonTimes Class
Used to calculate Active Directory logon times byte mask.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AdminAD
{
    public class PermittedLogonTimes
    {
        /// <summary>
        /// Calculates the byte mask for Active Directory Logon Times
        /// </summary>
        /// <param name="logonTimes">List of LogonTime objects to signify allows times</param>
        /// <returns>Active directory byte mask</returns>
        public static byte[] GetByteMask(List<LogonTime> logonTimes)
        {
            var hours = InitializeTimeArray();

            foreach (var time in logonTimes)
            {
                // skip a block to go to the 24 block set that represents the targetted day
                var dayOffset = (int)time.DayOfWeek * 24;

                // mark the hours
                MarkHours(hours, time);
            }

            // generate a byte [] for AD
            return ConvertToAD(hours);
        }

        /// <summary>
        /// Calculate the logon times based on an Active Directory byte mask
        /// </summary>
        /// <param name="byteMask">Active Directory byte mask</param>
        /// <returns>List of LogonTime objects to signify allows times</returns>
        public static List<LogonTime> GetLogonTimes(byte[] byteMask)
        {
            var zone = TimeZoneInfo.FindSystemTimeZoneById("E. South America Standard Time");
            return GetLogonTimes(byteMask, zone);
        }

        /// <summary>
        /// Calculate the logon times based on an Active Directory byte mask
        /// </summary>
        /// <param name="byteMask">Active Directory byte mask</param>
        /// <param name="timeZone">Time zone to convert to</param>
        /// <returns>List of LogonTime objects to signify allows times</returns>
        public static List<LogonTime> GetLogonTimes(byte[] byteMask, TimeZoneInfo timeZone)
        {
            var hours = MarkHours(byteMask);

            return ConvertToLogonTime(hours, (timeZone.BaseUtcOffset.Hours));
        }

        /// <summary>
        /// Initialize an array for every hour of everyday for a week
        /// </summary>
        /// <remarks>
        /// Each slot represents an hour of a day.  Ex. [0]=sunday 12am GMT, [1]=sunday 1am GMT ...
        ///
        /// During calculations based on time offset, hours will shift, Ex. [0]=sunday 1am GMT-1, [1]=sunday 2am GMT-1 ...
        ///
        /// PST Calcuation (GMT -8): [9]=sunday 8am, [1]=sunday 9am
        ///
        /// All values will be stored with an offset relative to GMT
        /// </remarks>
        /// <returns></returns>
        private static bool[] InitializeTimeArray()
        {
            var array = new bool[168];

            for (var i = 0; i < array.Count(); i++)
            {
                array[i] = false;
            }

            return array;
        }

        /// <summary>
        /// Mark the hours that have been selected
        /// </summary>
        /// <param name="hours"></param>
        /// <param name="logonTime"></param>
        private static void MarkHours(bool[] hours, LogonTime logonTime)
        {
            // hour offset, from GMT
            var offset = logonTime.TimeZoneOffSet;
            // day offset in the array
            var dayOffset = (int)logonTime.DayOfWeek * 24;

            // iterate through each of the hours of the day
            for (int i = 0; i < 24; i++)
            {
                // is the hour between what we're looking for
                if (logonTime.BeginTime.Hour <= i && i < logonTime.EndTime.Hour)
                {
                    // figure out which location to mark
                    var index = dayOffset + i + offset;

                    if (index < 0)
                    {
                        index = hours.Count() + index;
                    }
                    else if (index > hours.Count())
                    {
                        index = index - hours.Count();
                    }

                    hours[index] = true;
                }
            }

        }

        /// <summary>
        /// Convert the bool array to an AD byte mask
        /// </summary>
        /// <param name="hours"></param>
        /// <returns></returns>
        private static byte[] ConvertToAD(bool[] hours)
        {
            var permittedHours = new byte[21];
            var index = 0;  // index through the hours array
            var index2 = 0; // index through the permitted hours array

            while (index < hours.Length)
            {
                var result = ConvertBlockToAD(hours.Skip(index).Take(24).ToArray());

                permittedHours[index2] = result[0];
                permittedHours[index2 + 1] = result[1];
                permittedHours[index2 + 2] = result[2];

                index += 24;
                index2 += 3;
            }

            return permittedHours;
        }

        /// <summary>
        /// Convert individual blocks into AD
        /// </summary>
        /// <param name="hours"></param>
        /// <returns></returns>
        private static byte[] ConvertBlockToAD(bool[] hours)
        {
            var set = new int[3];

            for (var i = 0; i < 24; i++)
            {
                if (hours[i])
                {
                    var index = (int)Math.Floor((decimal)(i) / 8);
                    set[index] += CalculateLocationValue(i);
                }

            }

            return new byte[3] { Convert.ToByte(set[0]), Convert.ToByte(set[1]), Convert.ToByte(set[2]) };
        }

        /// <summary>
        /// Calculate individual byte mask locations
        /// </summary>
        /// <param name="location"></param>
        /// <returns></returns>
        private static int CalculateLocationValue(int location)
        {
            location = location % 8;

            switch (location)
            {
                case 0: return 1;
                case 1: return 2;
                case 2: return 4;
                case 3: return 8;
                case 4: return 16;
                case 5: return 32;
                case 6: return 64;
                case 7: return 128;
            }

            return 0;
        }

        /// <summary>
        /// Fills in an hour array based on bytemask
        /// </summary>
        /// <param name="byteMask"></param>
        private static bool[] MarkHours(byte[] byteMask)
        {
            var hours = InitializeTimeArray();

            for (var i = 0; i < byteMask.Length; i++)
            {
                ParseBlock(byteMask[i], hours, i * 8);
            }

            return hours;
        }

        /// <summary>
        /// Convert the byte block back into the array
        /// </summary>
        /// <param name="block"></param>
        /// <param name="hours"></param>
        /// <param name="index"></param>
        private static void ParseBlock(byte block, bool[] hours, int index)
        {
            var value = (int)block;

            if (value >= 128)
            {
                hours[index + 7] = true;
                value -= 128;
            }
            if (value >= 64)
            {
                hours[index + 6] = true;
                value -= 64;
            }
            if (value >= 32)
            {
                hours[index + 5] = true;
                value -= 32;
            }
            if (value >= 16)
            {
                hours[index + 4] = true;
                value -= 16;
            }
            if (value >= 8)
            {
                hours[index + 3] = true;
                value -= 8;
            }
            if (value >= 4)
            {
                hours[index + 2] = true;
                value -= 4;
            }
            if (value >= 2)
            {
                hours[index + 1] = true;
                value -= 2;
            }
            if (value >= 1)
            {
                hours[index] = true;
                value -= 1;
            }
        }

        private static List<LogonTime> ConvertToLogonTime(bool[] hours, int offset)
        {
            var ltimes = new List<LogonTime>();

            int? begin = null, end = null;

            for (var i = 0; i < hours.Length; i++)
            {
                var index = i + (-1) * offset;

                // shifts over begging, loop back to the end
                if (index < 0)
                {
                    index = hours.Length + index;
                }
                // shifts over end, start back from beginning of array
                else if (index >= hours.Length)
                {
                    index = index - hours.Length;
                }

                if (!begin.HasValue && hours[index])
                {
                    begin = CalculateHour(index, offset);
                }
                else if (begin.HasValue && !hours[index])
                {
                    end = CalculateHour(index, offset);


                    if (end < 0) continue;

                    // save the day
                    ltimes.Add(new LogonTime(CalculateDay(index, offset), new DateTime(2011, 1, 1, begin.Value, 0, 0), new DateTime(2011, 1, 1, end.Value, 0, 0)));

                    begin = null;
                    end = null;
                }

            }

            return ltimes;
        }

        private static int CalculateHour(int index, int offset)
        {
            var hour = index + offset;
            hour = hour % 24;

            return hour;
        }

        private static DayOfWeek CalculateDay(int index, int offset)
        {
            var day = Math.Floor((decimal)(index + offset) / 24);

            return (DayOfWeek)day;
        }
    }
}

LogonTimes Class
LogonTime – is used to pass the information for logon for a specific day.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace AdminAD
{
    public class LogonTime
    {
        public DayOfWeek DayOfWeek { get; set; }
        public DateTime BeginTime { get; set; }
        public DateTime EndTime { get; set; }

        public int TimeZoneOffSet { get; set; }

        public LogonTime(DayOfWeek dayOfWeek, DateTime beginTime, DateTime endTime)
        {
            DayOfWeek = dayOfWeek;
            BeginTime = beginTime;
            EndTime = endTime;

            SetOffset(TimeZoneInfo.FindSystemTimeZoneById("E. South America Standard Time"));
           // ValidateTimes();
        }

        public LogonTime(DayOfWeek dayOfWeek, TimeSpan begin, TimeSpan end)
        {
            DayOfWeek = dayOfWeek;
            BeginTime = new DateTime(begin.Ticks);
            EndTime = new DateTime(end.Ticks);

            SetOffset(TimeZoneInfo.FindSystemTimeZoneById("E. South America Standard Time"));
           // ValidateTimes();
        }

        public LogonTime(DayOfWeek dayOfWeek, DateTime beginTime, DateTime endTime, TimeZoneInfo timeZone)
        {
            DayOfWeek = dayOfWeek;
            BeginTime = beginTime;
            EndTime = endTime;

            SetOffset(timeZone);
           // ValidateTimes();
        }

        public LogonTime(DayOfWeek dayOfWeek, TimeSpan begin, TimeSpan end, TimeZoneInfo timeZone)
        {
            DayOfWeek = dayOfWeek;
            BeginTime = new DateTime(begin.Ticks);
            EndTime = new DateTime(end.Ticks);

            SetOffset(timeZone);
           // ValidateTimes();
        }

        private void SetOffset(TimeZoneInfo timeZone)
        {
            TimeZoneOffSet = (-1) * (timeZone.BaseUtcOffset.Hours);
            //TimeZoneOffSet = timeZone.IsDaylightSavingTime(DateTime.Now) ? (-1) * (timeZone.GetUtcOffset(DateTime.Now).Hours - 1) : (-1)*(timeZone.GetUtcOffset(DateTime.Now).Hours);
        }

        private void ValidateTimes()
        {
            if (EndTime.Hour < BeginTime.Hour)
            {
                throw new ArgumentException("Begin time cannot be after End time.");
            }
        }
    }

}

Form Class, where I view the allowed times and select new times.
Using the Save button to apply the new times in AD.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using System.DirectoryServices;
using System.DirectoryServices.AccountManagement;
using FontAwesome.Sharp;

namespace AdminAD
{
    public partial class frmHorarioAD : Form
    {
        public bool IsManager { get; protected set; }

        private Form currentChildForm;
        private IconButton currentBtn;
        private Panel leftBorderBtn;


        public string userlogado
        {

            get { return lbNomeCompleto.Text; }
            set { lbNomeCompleto.Text = value; }
        }

        string usuarioAD;
        string senhaAD;



        private int cv_iSunFromTime = -2, cv_iSunToTime = -2;
        private int cv_iMonFromTime = -2, cv_iMonToTime = -2;
        private int cv_iTueFromTime = -2, cv_iTueToTime = -2;
        private int cv_iWedFromTime = -2, cv_iWedToTime = -2;
        private int cv_iThuFromTime = -2, cv_iThuToTime = -2;
        private int cv_iFriFromTime = -2, cv_iFriToTime = -2;
        private int cv_iSatFromTime = -2, cv_iSatToTime = -2;

        private void cmbSunToTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }

        private void cmbMonFromTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }

        private void cmbMonToTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }

        private void cmbTueFromTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }

        private void cmbTueToTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }

        private void cmbWedFromTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }

        private void cmbWedToTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }

        private void cmbThuFromTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }

        private void cmbThuToTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }

        private void cmbFriFromTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }

        private void cmbFriToTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }



        private void cmbSatFromTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }



        private void cmbSatToTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }



        private void cmbSunFromTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnSave.Enabled = true;
        }

        private void frmHorarioAD_Load(object sender, EventArgs e)
        {

            dgListUsuario.ClearSelection();

        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (currentChildForm != null)
            {
                currentChildForm.Close();
            }
            Reset();
            this.Close();
        }

        public void Reset()
        {
            DisableButton();
            leftBorderBtn.Visible = false;

        }

        private void DisableButton()
        {
            if (currentBtn != null)
            {
                currentBtn.BackColor = Color.FromArgb(0, 81, 135);
                currentBtn.ForeColor = Color.Gainsboro;
                currentBtn.TextAlign = ContentAlignment.MiddleLeft;
                currentBtn.IconColor = Color.Gainsboro;
                currentBtn.TextImageRelation = TextImageRelation.ImageBeforeText;
                currentBtn.ImageAlign = ContentAlignment.MiddleLeft;
            }
        }


        public frmHorarioAD(string usuario, string senha, string nomecompleto)
        {
            InitializeComponent();

            lbNomeCompleto.Text = usuario;

            usuarioAD = usuario;
            senhaAD = senha;


            leftBorderBtn = new Panel();
            leftBorderBtn.Size = new Size(7, 60);


            carregarDGUsuario(usuario, senha, nomecompleto);

            this.dgListUsuario.EnableHeadersVisualStyles = false;


            // Clear and load the hourly times in the From and To time drop down lists
            DateTime dtFromTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, 0);
            DateTime dtToTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, 0);

            cmbSunFromTime.Items.Clear();
            cmbMonFromTime.Items.Clear();
            cmbTueFromTime.Items.Clear();
            cmbWedFromTime.Items.Clear();
            cmbThuFromTime.Items.Clear();
            cmbFriFromTime.Items.Clear();
            cmbSatFromTime.Items.Clear();
            cmbSunToTime.Items.Clear();
            cmbMonToTime.Items.Clear();
            cmbTueToTime.Items.Clear();
            cmbWedToTime.Items.Clear();
            cmbThuToTime.Items.Clear();
            cmbFriToTime.Items.Clear();
            cmbSatToTime.Items.Clear();

            for (int iIndex = 0; iIndex < 24; iIndex++)
            {
                cmbSunFromTime.Items.Add(dtFromTime.ToShortTimeString());
                cmbMonFromTime.Items.Add(dtFromTime.ToShortTimeString());
                cmbTueFromTime.Items.Add(dtFromTime.ToShortTimeString());
                cmbWedFromTime.Items.Add(dtFromTime.ToShortTimeString());
                cmbThuFromTime.Items.Add(dtFromTime.ToShortTimeString());
                cmbFriFromTime.Items.Add(dtFromTime.ToShortTimeString());
                cmbSatFromTime.Items.Add(dtFromTime.ToShortTimeString());
                cmbSunToTime.Items.Add(dtToTime.ToShortTimeString());
                cmbMonToTime.Items.Add(dtToTime.ToShortTimeString());
                cmbTueToTime.Items.Add(dtToTime.ToShortTimeString());
                cmbWedToTime.Items.Add(dtToTime.ToShortTimeString());
                cmbThuToTime.Items.Add(dtToTime.ToShortTimeString());
                cmbFriToTime.Items.Add(dtToTime.ToShortTimeString());
                cmbSatToTime.Items.Add(dtToTime.ToShortTimeString());
                dtFromTime = dtFromTime.AddHours(1);
                dtToTime = dtToTime.AddHours(1);
            }
        }


        public void carregarDGUsuario(string usuario, string senha, string nomecompleto)

        {
            try
            {
                List<string> usuarioSubordinado = new List<string>();

                DataTable tabela = new DataTable();
                tabela.Columns.Add("Nome", typeof(string));
                tabela.Columns.Add("UsuarioAD", typeof(string));
                tabela.Columns.Add("Função", typeof(string));


                DirectoryEntry Servidor = new DirectoryEntry("LDAP://192.0.64.151", usuario, senha);
                object nativeObject = Servidor.NativeObject;

                DirectorySearcher pesquisa = new DirectorySearcher(Servidor);

                pesquisa.Filter = "(&((&(objectCategory=Person)(objectClass=User)))(manager=" + nomecompleto + "))";
                pesquisa.PropertiesToLoad.Add("samaccountname");
                pesquisa.PropertiesToLoad.Add("DisplayName");
                pesquisa.PropertiesToLoad.Add("userAccountControl");
                pesquisa.PropertiesToLoad.Add("mail");
                pesquisa.PropertiesToLoad.Add("title");
                pesquisa.PropertiesToLoad.Add("company");


                SearchResult result;
                SearchResultCollection resultCol = pesquisa.FindAll();
                if (resultCol != null)
                {
                    for (int counter = 0; counter < resultCol.Count; counter++)
                    {
                        result = resultCol[counter];

                        if (result.Properties.Contains("samaccountname"))

                        {
                            var vaPropertiy = result.Properties["userAccountControl"];

                            if (vaPropertiy.Count > 0)
                            {
                                if (vaPropertiy[0].ToString() == "512" || vaPropertiy[0].ToString() == "66048" || vaPropertiy[0].ToString() == "544")
                                {
                                    DataRow dr = tabela.NewRow();
                                    dr["Nome"] = result.Properties["DisplayName"][0];
                                    dr["UsuarioAD"] = result.Properties["samaccountname"][0];
                                    dr["Função"] = result.Properties["title"][0];


                                    tabela.Rows.Add(dr);


                                }

                                dgListUsuario.DataSource = tabela;
                                dgListUsuario.ReadOnly = true;
                            }


                        }
                    }


                }

                else
                {

                    MessageBox.Show("Usuário não é Gerente", "SGAD-Sistema de Gestão do AD", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    Menu formenu = new Menu();
                    this.Hide();
                    formenu.Reset();

                }

            }

            catch
            {
                MessageBox.Show("Usuário não é Manager");
            }
        }

        private void dgListUsuario_SelectionChanged(object sender, EventArgs e)
        {


            foreach (DataGridViewRow row in dgListUsuario.SelectedRows)
            {

                string nomeusuario = row.Cells[1].Value.ToString();
                carregarHorario(nomeusuario);
                lbUserSelecionado.Text = row.Cells[1].Value.ToString();

            }


        }

        public void carregarHorario(string NomeUsuario)
        {
            var varSelectedUserLogonTimes = new List<LogonTime>();
            String sSelectedUserName = "";
            PrincipalContext pctxLocalMachine;
            UserPrincipal usrpSelectedUser;

            string servidor = "192.0.64.151";
            string userAD = usuarioAD;
            string pwdAD = senhaAD;
            sSelectedUserName = NomeUsuario;
            pctxLocalMachine = new PrincipalContext(ContextType.Domain, servidor, userAD, pwdAD);
            usrpSelectedUser = UserPrincipal.FindByIdentity(pctxLocalMachine, IdentityType.SamAccountName, sSelectedUserName);


            if (usrpSelectedUser.Enabled == true)
            {
                cmbSunFromTime.Enabled = true;
                cmbSunToTime.Enabled = true;
                cmbMonFromTime.Enabled = true;
                cmbMonToTime.Enabled = true;
                cmbTueFromTime.Enabled = true;
                cmbTueToTime.Enabled = true;
                cmbWedFromTime.Enabled = true;
                cmbWedToTime.Enabled = true;
                cmbThuFromTime.Enabled = true;
                cmbThuToTime.Enabled = true;
                cmbFriFromTime.Enabled = true;
                cmbFriToTime.Enabled = true;
                cmbSatFromTime.Enabled = true;
                cmbSatToTime.Enabled = true;
                btnSave.Enabled = true;
            }
            else
            {
                cmbSunFromTime.Enabled = false;
                cmbSunToTime.Enabled = false;
                cmbMonFromTime.Enabled = false;
                cmbMonToTime.Enabled = false;
                cmbTueFromTime.Enabled = false;
                cmbTueToTime.Enabled = false;
                cmbWedFromTime.Enabled = false;
                cmbWedToTime.Enabled = false;
                cmbThuFromTime.Enabled = false;
                cmbThuToTime.Enabled = false;
                cmbFriFromTime.Enabled = false;
                cmbFriToTime.Enabled = false;
                cmbSatFromTime.Enabled = false;
                cmbSatToTime.Enabled = false;
                btnSave.Enabled = false;
            }

            varSelectedUserLogonTimes = PermittedLogonTimes.GetLogonTimes(usrpSelectedUser.PermittedLogonTimes);

            cmbSunFromTime.SelectedIndex = -1;
            cmbMonFromTime.SelectedIndex = -1;
            cmbTueFromTime.SelectedIndex = -1;
            cmbWedFromTime.SelectedIndex = -1;
            cmbThuFromTime.SelectedIndex = -1;
            cmbFriFromTime.SelectedIndex = -1;
            cmbSatFromTime.SelectedIndex = -1;
            cmbSunToTime.SelectedIndex = -1;
            cmbMonToTime.SelectedIndex = -1;
            cmbTueToTime.SelectedIndex = -1;
            cmbWedToTime.SelectedIndex = -1;
            cmbThuToTime.SelectedIndex = -1;
            cmbFriToTime.SelectedIndex = -1;
            cmbSatToTime.SelectedIndex = -1;

            for (int iIndex = 0; iIndex < varSelectedUserLogonTimes.Count; iIndex++)
            {
                LogonTime lExtractedTime = varSelectedUserLogonTimes.ElementAt(iIndex);

                switch (lExtractedTime.DayOfWeek)
                {
                    case DayOfWeek.Sunday:
                        cv_iSunFromTime = cmbSunFromTime.SelectedIndex = cmbSunFromTime.Items.IndexOf(lExtractedTime.BeginTime.ToShortTimeString());
                        cv_iSunToTime = cmbSunToTime.SelectedIndex = cmbSunToTime.Items.IndexOf(lExtractedTime.EndTime.ToShortTimeString());
                        break;
                    case DayOfWeek.Monday:
                        cv_iMonFromTime = cmbMonFromTime.SelectedIndex = cmbMonFromTime.Items.IndexOf(lExtractedTime.BeginTime.ToShortTimeString());
                        cv_iMonToTime = cmbMonToTime.SelectedIndex = cmbMonToTime.Items.IndexOf(lExtractedTime.EndTime.ToShortTimeString());
                        break;
                    case DayOfWeek.Tuesday:
                        cv_iTueFromTime = cmbTueFromTime.SelectedIndex = cmbTueFromTime.Items.IndexOf(lExtractedTime.BeginTime.ToShortTimeString());
                        cv_iTueToTime = cmbTueToTime.SelectedIndex = cmbTueToTime.Items.IndexOf(lExtractedTime.EndTime.ToShortTimeString());
                        break;
                    case DayOfWeek.Wednesday:
                        cv_iWedFromTime = cmbWedFromTime.SelectedIndex = cmbWedFromTime.Items.IndexOf(lExtractedTime.BeginTime.ToShortTimeString());
                        cv_iWedToTime = cmbWedToTime.SelectedIndex = cmbWedToTime.Items.IndexOf(lExtractedTime.EndTime.ToShortTimeString());
                        break;
                    case DayOfWeek.Thursday:
                        cv_iThuFromTime = cmbThuFromTime.SelectedIndex = cmbThuFromTime.Items.IndexOf(lExtractedTime.BeginTime.ToShortTimeString());
                        cv_iThuToTime = cmbThuToTime.SelectedIndex = cmbThuToTime.Items.IndexOf(lExtractedTime.EndTime.ToShortTimeString());
                        break;
                    case DayOfWeek.Friday:
                        cv_iFriFromTime = cmbFriFromTime.SelectedIndex = cmbFriFromTime.Items.IndexOf(lExtractedTime.BeginTime.ToShortTimeString());
                        cv_iFriToTime = cmbFriToTime.SelectedIndex = cmbFriToTime.Items.IndexOf(lExtractedTime.EndTime.ToShortTimeString());
                        break;
                    case DayOfWeek.Saturday:
                        cv_iSatFromTime = cmbSatFromTime.SelectedIndex = cmbSatFromTime.Items.IndexOf(lExtractedTime.BeginTime.ToShortTimeString());
                        cv_iSatToTime = cmbSatToTime.SelectedIndex = cmbSatToTime.Items.IndexOf(lExtractedTime.EndTime.ToShortTimeString());
                        break;
                }
            }

        }

        private void btnSave_Click(object sender, EventArgs e)
        {
            DateTime dtSunFromTime, dtMonFromTime, dtTueFromTime, dtWedFromTime, dtThuFromTime, dtFriFromTime, dtSatFromTime;
            DateTime dtSunToTime, dtMonToTime, dtTueToTime, dtWedToTime, dtThuToTime, dtFriToTime, dtSatToTime;
            String sSelectedUserName = "", sFromTime = "", sToTime = "";
            LogonTime lSunLogonTime, lMonLogonTime, lTueLogonTime, lWedLogonTime;
            LogonTime lThuLogonTime, lFriLogonTime, lSatLogonTime;
            List<LogonTime> lstLogonTimes = new List<LogonTime>();
            PrincipalContext pctxLocalMachine;
            UserPrincipal usrpSelectedUser;


            string servidor = "192.0.64.151";
            string userAD = usuarioAD;
            string pwdAD = senhaAD;
            sSelectedUserName = lbUserSelecionado.Text;//cmbUserList.SelectedItem.ToString();
            pctxLocalMachine = new PrincipalContext(ContextType.Domain, servidor, userAD, pwdAD);
            usrpSelectedUser = UserPrincipal.FindByIdentity(pctxLocalMachine, IdentityType.SamAccountName, sSelectedUserName);

            if (cmbSunFromTime.SelectedItem != null & cmbSunToTime.SelectedItem != null)
            {
                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + cmbSunFromTime.SelectedItem.ToString();
                sToTime = sToTime + cmbSunToTime.SelectedItem.ToString();
                dtSunFromTime = DateTime.Parse(sFromTime);
                dtSunToTime = DateTime.Parse(sToTime);
                lSunLogonTime = new LogonTime(System.DayOfWeek.Sunday, dtSunFromTime, dtSunToTime);
                lstLogonTimes.Add(lSunLogonTime);
            }
            else
            {

                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + "00:00";
                sToTime = sToTime + "00:00";
                dtSunFromTime = DateTime.Parse(sFromTime);
                dtSunToTime = DateTime.Parse(sToTime);
                lSunLogonTime = new LogonTime(System.DayOfWeek.Sunday, dtSunFromTime, dtSunToTime);
                lstLogonTimes.Add(lSunLogonTime);
            }

            if (cmbMonFromTime.SelectedItem != null & cmbMonToTime.SelectedItem != null)
            {

                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + cmbMonFromTime.SelectedItem.ToString();
                sToTime = sToTime + cmbMonToTime.SelectedItem.ToString();
                dtMonFromTime = DateTime.Parse(sFromTime);
                dtMonToTime = DateTime.Parse(sToTime);
                lMonLogonTime = new LogonTime(System.DayOfWeek.Monday, dtMonFromTime, dtMonToTime);
                lstLogonTimes.Add(lMonLogonTime);
            }
            else
            {
                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + "00:00";
                sToTime = sToTime + "00:00";
                dtMonFromTime = DateTime.Parse(sFromTime);
                dtMonToTime = DateTime.Parse(sToTime);
                lMonLogonTime = new LogonTime(System.DayOfWeek.Monday, dtMonFromTime, dtMonToTime);
                lstLogonTimes.Add(lMonLogonTime);


            }

            if (cmbTueFromTime.SelectedItem != null & cmbTueToTime.SelectedItem != null)
            {
                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + cmbTueFromTime.SelectedItem.ToString();
                sToTime = sToTime + cmbTueToTime.SelectedItem.ToString();
                dtTueFromTime = DateTime.Parse(sFromTime);
                dtTueToTime = DateTime.Parse(sToTime);
                lTueLogonTime = new LogonTime(System.DayOfWeek.Tuesday, dtTueFromTime, dtTueToTime);
                lstLogonTimes.Add(lTueLogonTime);
            }
            else
            {
                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + "00:00";
                sToTime = sToTime + "00:00";
                dtTueFromTime = DateTime.Parse(sFromTime);
                dtTueToTime = DateTime.Parse(sToTime);
                lTueLogonTime = new LogonTime(System.DayOfWeek.Tuesday, dtTueFromTime, dtTueToTime);
                lstLogonTimes.Add(lTueLogonTime);

            }

            if (cmbWedFromTime.SelectedItem != null & cmbWedToTime.SelectedItem != null)
            {

                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + cmbWedFromTime.SelectedItem.ToString();
                sToTime = sToTime + cmbWedToTime.SelectedItem.ToString();
                dtWedFromTime = DateTime.Parse(sFromTime);
                dtWedToTime = DateTime.Parse(sToTime);
                lWedLogonTime = new LogonTime(System.DayOfWeek.Wednesday, dtWedFromTime, dtWedToTime);
                lstLogonTimes.Add(lWedLogonTime);
            }
            else
            {
                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + "00:00";
                sToTime = sToTime + "00:00";
                dtWedFromTime = DateTime.Parse(sFromTime);
                dtWedToTime = DateTime.Parse(sToTime);
                lWedLogonTime = new LogonTime(System.DayOfWeek.Wednesday, dtWedFromTime, dtWedToTime);
                lstLogonTimes.Add(lWedLogonTime);

            }

            if (cmbThuFromTime.SelectedItem != null & cmbThuToTime.SelectedItem != null)
            {
                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + cmbThuFromTime.SelectedItem.ToString();
                sToTime = sToTime + cmbThuToTime.SelectedItem.ToString();
                dtThuFromTime = DateTime.Parse(sFromTime);
                dtThuToTime = DateTime.Parse(sToTime);
                lThuLogonTime = new LogonTime(System.DayOfWeek.Thursday, dtThuFromTime, dtThuToTime);
                lstLogonTimes.Add(lThuLogonTime);

            }
            else
            {
                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + "00:00";
                sToTime = sToTime + "00:00";
                dtThuFromTime = DateTime.Parse(sFromTime);
                dtThuToTime = DateTime.Parse(sToTime);
                lThuLogonTime = new LogonTime(System.DayOfWeek.Thursday, dtThuFromTime, dtThuToTime);
                lstLogonTimes.Add(lThuLogonTime);

            }


            if (cmbFriFromTime.SelectedItem != null & cmbFriToTime.SelectedItem != null)
            {
                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + cmbFriFromTime.SelectedItem.ToString();
                sToTime = sToTime + cmbFriToTime.SelectedItem.ToString();
                dtFriFromTime = DateTime.Parse(sFromTime);
                dtFriToTime = DateTime.Parse(sToTime);
                lFriLogonTime = new LogonTime(System.DayOfWeek.Friday, dtFriFromTime, dtFriToTime);
                lstLogonTimes.Add(lFriLogonTime);

            }
            else
            {
                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + "00:00";
                sToTime = sToTime + "00:00";
                dtFriFromTime = DateTime.Parse(sFromTime);
                dtFriToTime = DateTime.Parse(sToTime);
                lFriLogonTime = new LogonTime(System.DayOfWeek.Friday, dtFriFromTime, dtFriToTime);
                lstLogonTimes.Add(lFriLogonTime);

            }

            if (cmbSatFromTime.SelectedItem != null & cmbSatToTime.SelectedItem != null)
            {
                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + cmbSatFromTime.SelectedItem.ToString();
                sToTime = sToTime + cmbSatToTime.SelectedItem.ToString();
                dtSatFromTime = DateTime.Parse(sFromTime);
                dtSatToTime = DateTime.Parse(sToTime);
                lSatLogonTime = new LogonTime(System.DayOfWeek.Saturday, dtSatFromTime, dtSatToTime);
                lstLogonTimes.Add(lSatLogonTime);
            }
            else
            {
                sFromTime = "1/1/" + DateTime.Now.Year + " "; sToTime = "1/1/" + DateTime.Now.Year + " ";
                sFromTime = sFromTime + "00:00";
                sToTime = sToTime + "00:00";
                dtSatFromTime = DateTime.Parse(sFromTime);
                dtSatToTime = DateTime.Parse(sToTime);
                lSatLogonTime = new LogonTime(System.DayOfWeek.Saturday, dtSatFromTime, dtSatToTime);
                lstLogonTimes.Add(lSatLogonTime);
            }



            if (cmbSunFromTime.SelectedIndex == cv_iSunFromTime &&
                cmbSunToTime.SelectedIndex == cv_iSunToTime &&
                cmbMonFromTime.SelectedIndex == cv_iMonFromTime &&
                cmbMonToTime.SelectedIndex == cv_iMonToTime &&
                cmbTueFromTime.SelectedIndex == cv_iTueFromTime &&
                cmbTueToTime.SelectedIndex == cv_iTueToTime &&
                cmbWedFromTime.SelectedIndex == cv_iWedFromTime &&
                cmbWedToTime.SelectedIndex == cv_iWedToTime &&
                cmbThuFromTime.SelectedIndex == cv_iThuFromTime &&
                cmbThuToTime.SelectedIndex == cv_iThuToTime &&
                cmbFriFromTime.SelectedIndex == cv_iFriFromTime &&
                cmbFriToTime.SelectedIndex == cv_iFriToTime &&
                cmbSatFromTime.SelectedIndex == cv_iSatFromTime &&
                cmbSatToTime.SelectedIndex == cv_iSatToTime)
            {
                MessageBox.Show("Nenhuma alteração feita que precise ser salva!", "SGAD", MessageBoxButtons.OK, MessageBoxIcon.Information);
                btnSave.Enabled = false;
            }
            else
            {
                byte[] byteMaskForUser;

                // Saving Permitted Logon Times based on selection
                byteMaskForUser = PermittedLogonTimes.GetByteMask(lstLogonTimes);
                usrpSelectedUser.PermittedLogonTimes = byteMaskForUser;
                usrpSelectedUser.Save();



                MessageBox.Show("As alterações de limite de tempo do usuário:" + usrpSelectedUser.Name + " foram salvas com sucesso no Servidor!", "SGAD", MessageBoxButtons.OK, MessageBoxIcon.Information);

                usrpSelectedUser.Dispose();
                pctxLocalMachine.Dispose();

                btnSave.Enabled = false;
            }

            carregarHorario(lbUserSelecionado.Text);

        }

    }

}

 

[Skydiver]

After ToShortTimeString, combo boxes are populated with times starting from 00:00 to 23:00

You still didn't tell use what the resulting string from ToShortTimeString() is coming back as.

Well, obviously the result of ToShortTimeString() isn't matching anything in your Saturday combo boxes based on your screenshot in post #7. I really recommend reviewing the combo box values, specially to see if you have any leading or trailing spaces.

What you say is the other topic, it's actually the same topic, but looking at the part that the system brings the AD time mask.

But by bring up that the wrong day is being returned would suggest that there is a bug in the conversion from the bitmap into your LogonTime list.

Regardless if the data is coming back as Saturday instead of your expected Friday, there should have still been a matching string in the combo box because you were finding matches for the combo boxes for the other days.

Thanks for sharing the code that converts from bitmask to LogonTime. I'll take a look later when I'm not running around like chicken with it's head cut off.

 

[NoUserHere]

Op needs this : Tutorial: Debug C# code - Visual Studio

 

[NoUserHere]

There is only so much help you can get if you avoid answering questions. Clearly his assumptions aren't and shouldn't be trusted since he is only second guessing your code. Wouldn't you want to be sure?

By right, you should be debugging your code, instead of asking others on a public forum to help you understand the logic you wrote wrongly. Debugging should be the first step you take before even asking for help on a forum.

 

[julierme]

There is only so much help you can get if you avoid answering questions. Clearly his assumptions aren't and shouldn't be trusted since he is only second guessing your code. Wouldn't you want to be sure?

By right, you should be debugging your code, instead of asking others on a public forum to help you understand the logic you wrote wrongly. Debugging should be the first step you take before even asking for help on a forum.

Dear,

First of all, I want to tell you that I'm not an experienced developer working with infrastructure but I'm passionate about programming.
Sorry for the mistakes, I'll be looking to improve, I just think you understand.

I start debugging in this step, because here it is passing the mask of allowed times of the selected user and returning a list of LogonTime objects.

Then I'm debugging ToShorTimeString() to know what will be loaded in the combo boxes.

And the combox will be filled as shown in the image

And the combox will be filled as shown in the image

Note that no time is selected until midnight, and in the case of Sunday no time is selected. When it's like that it's correct.
But when adding time that goes until midnight or all day allowed, the error occurs.


I believe the error is in the conversion of the mask that comes from AD to LogonTime.
Would have to check every PermittedLogonTimes class

 

[NoUserHere]

I want to tell you that I'm not an experienced developer working with infrastructure but I'm passionate about programming.

I respect that. I do. There are a lot of imbeciles who come to forums like this one just for fast answers, and they don't care to understand the code they are given back once it works for them. I admire those who show your enthusiasm for learning. And this is a good start. Using the debugger is a good step forward, and its your best friend when programming within Visual Studio...

I start debugging in this step, because here it is passing the mask of allowed times of the selected user and returning a list of LogonTime objects.

Set LogonHours Active Directory

Dear, I'm developing a system to restrict user login times in AD, I can view login times and even change. But for example, I'm not able to establish this login time from 17:00 to midnight, the system appears to be zero, another issue is to establish the time from 00:00 to 00:00, when this done...

csharpforums.net

Check the link, and start debugging and report back on what you were previously asked for on p1/#6.

 

[Skydiver]

Ah, no wonder our OP was kind of hesitant to debug the code for bitmap to LogonTime list conversion, and vice versa. The code looks to have just been lifted from:

Permitted-Logon-Times-for-Active-Directory/ADPermittedLogonTime/PermittedLogonTimes.cs at master · anlai/Permitted-Logon-Times-for-Active-Directory

Contribute to anlai/Permitted-Logon-Times-for-Active-Directory development by creating an account on GitHub.

github.com

And here is the accompanying blog post about the code:

Active Directory Permitted Logon Times with C# .Net 3.5 using System.DirectoryServices.AccountManagement

Recently I was working on a proof of concept for some active directory manipulation. Using the System.DirectoryServices.AccountManagement was the easiest and best option for managing accounts (as …

anlai.wordpress.com

 

[Skydiver]

Line 291 of PermittedLogonTimes.cs passes in the index of the first free hour after a run of used hours. Let's just do UTC for simplicity. If a person's shift begins at 11PM Sunday and ends at 12AM Monday, then the first used hour will be index 23 and the first free block will be index 24. CalculateDay() basically divides the index by 24. So 24 / 24 == 1. 1 casted to a DayOfWeek becomes a Monday, instead of the expected Sunday.

 

[julierme]

Ah, no wonder our OP was kind of hesitant to debug the code for bitmap to LogonTime list conversion, and vice versa. The code looks to have just been lifted from:

Permitted-Logon-Times-for-Active-Directory/ADPermittedLogonTime/PermittedLogonTimes.cs at master · anlai/Permitted-Logon-Times-for-Active-Directory

Contribute to anlai/Permitted-Logon-Times-for-Active-Directory development by creating an account on GitHub.

github.com

And here is the accompanying blog post about the code:

Active Directory Permitted Logon Times with C# .Net 3.5 using System.DirectoryServices.AccountManagement

Recently I was working on a proof of concept for some active directory manipulation. Using the System.DirectoryServices.AccountManagement was the easiest and best option for managing accounts (as …

anlai.wordpress.com

Yes, from the beginning I informed that the code of the PermittedLogonTimes and LogonTimes classes was not mine and put a link that led to them.

 

[julierme]

Line 291 of PermittedLogonTimes.cs passes in the index of the first free hour after a run of used hours. Let's just do UTC for simplicity. If a person's shift begins at 11PM Sunday and ends at 12AM Monday, then the first used hour will be index 23 and the first free block will be index 24. CalculateDay() basically divides the index by 24. So 24 / 24 == 1. 1 casted to a DayOfWeek becomes a Monday, instead of the expected Sunday.

what do i have to do to solve?

 

[Skydiver]

Yes, from the beginning I informed that the code of the PermittedLogonTimes and LogonTimes classes was not mine and put a link that led to them.

It wasn't obvious that the code was not yours. If you had responded to my post #2 or post #3 regarding posting the code into the thread, or about changing the implementation by saying that the code was not yours and it was not your idea to implement it that way, then it would have been obvious. How were we supposed to know that your GitHub name was not anlai?

 

[Skydiver]

what do i have to do to solve?

Contact the original author of the code?

You could pass in the index of the beginning of the active block instead of the index of the first free block.

 

[julierme]

Contact the original author of the code?

You could pass in the index of the beginning of the active block instead of the index of the first free block.

actually i tried contacting the author but it was unsuccessful so far.
I will run some tests.
Thanks.

 

[NoUserHere]

A better solution would be to write your own code.

 

[julierme]

A better solution would be to write your own code.

I agree.
I will study a little more.
Thanks for listening.