private void _refreshCache()
 {
     if (!string.IsNullOrEmpty(this.SQLConnectionString))
     {
         _cache = new Dictionary <int, AbsenceReason>();
         using (SqlConnection connection = new SqlConnection(SQLConnectionString))
         {
             using (SqlCommand sqlCommand = new SqlCommand())
             {
                 sqlCommand.Connection  = connection;
                 sqlCommand.CommandType = CommandType.Text;
                 sqlCommand.CommandText = SelectSQL;
                 sqlCommand.Connection.Open();
                 SqlDataReader dataReader = sqlCommand.ExecuteReader();
                 if (dataReader.HasRows)
                 {
                     while (dataReader.Read())
                     {
                         AbsenceReason parsedObject = dataReaderToObject(dataReader);
                         if (parsedObject != null)
                         {
                             _cache.Add(parsedObject.ID, parsedObject);
                         }
                     }
                 }
                 sqlCommand.Connection.Close();
             }
         }
     }
     else
     {
         throw new InvalidConnectionStringException("Connection string is empty");
     }
 }
        public static AbsenceReason CreateAbsenceReason(string dataAreaId, string absenceCode, string reasonCodeId, global::Microsoft.Dynamics.DataEntities.ReasonCode reasonCode)
        {
            AbsenceReason absenceReason = new AbsenceReason();

            absenceReason.dataAreaId   = dataAreaId;
            absenceReason.AbsenceCode  = absenceCode;
            absenceReason.ReasonCodeId = reasonCodeId;
            if ((reasonCode == null))
            {
                throw new global::System.ArgumentNullException("reasonCode");
            }
            absenceReason.ReasonCode = reasonCode;
            return(absenceReason);
        }
Example #3
0
        public async Task NotifyAbsence(string employee, AbsenceReason reason)
        {
            try
            {
                _logger.LogInformation(new { employee, reason }, s => $"Sending a notification: employee = {s.employee}, reason = {s.reason}");

                await _sns.PublishAsync(new PublishRequest
                {
                    TopicArn = topicArn,
                    Message  = $"{employee} reported an absence due to {reason:G}"
                });
            }
            catch (Exception ex)
            {
                throw;
            }
        }
        public async Task RegisterAbsenceAsync(string employee, DateTime date, AbsenceReason reason)
        {
            var newAbsence = new Absence
            {
                Employee   = employee,
                Date       = date.Date,
                InsertedOn = DateTime.Now,
                Reason     = reason
            };

            try
            {
                _logger.LogInformation(newAbsence, o => $"Persisting new absence: {o.Employee} reported {o.Reason:G} on {o.Date:yyyy-MM-dd} at {o.InsertedOn:s}");
                await _context.SaveAsync(newAbsence);
            }
            catch (Exception ex)
            {
                _logger.LogError(newAbsence, ex, (obj, e) => $"{e.Message} occurred when persisting {obj.Employee}'s absence");
                throw;
            }
        }
Example #5
0
        public static void Sync(ConfigFile configFile, LogDelegate Log)
        {
            ConfigFileSyncPermissionsSection config = configFile.AbsenceReasonPermissions
            ;

            Log("========= ABSENCE REASONS ========= ");
            if (!config.AllowSync)
            {
                Log("This sync module is disabled in config file - skipping");
                return;
            }
            InternalAbsenceReasonRepository internalRepository = new InternalAbsenceReasonRepository(configFile.DatabaseConnectionString_Internal);
            SLAbsenceReasonRepository       externalRepository = new SLAbsenceReasonRepository(configFile.DatabaseConnectionString_SchoolLogic);

            List <AbsenceReason> externalObjects = externalRepository.GetAll();

            Log("Found " + internalRepository.GetAllIDs().Count() + " reasons in internal database");
            Log("Found " + externalObjects.Count() + " reasons in external database");

            // Find previously unknown schools
            // Find schools that need an update
            List <AbsenceReason> previouslyUnknown = new List <AbsenceReason>();
            List <AbsenceReason> needingUpdate     = new List <AbsenceReason>();
            List <AbsenceReason> noLongerExistsInExternalSystem = new List <AbsenceReason>();

            foreach (AbsenceReason externalObject in externalObjects)
            {
                // Check to see if we know about this school already
                AbsenceReason internalObject = internalRepository.Get(externalObject.ID);
                if (internalObject == null)
                {
                    previouslyUnknown.Add(externalObject);
                }

                // Check to see if this school requires an update
                if (internalObject != null)
                {
                    UpdateCheck check = internalObject.CheckIfUpdatesAreRequired(externalObject);
                    if ((check == UpdateCheck.UpdatesRequired) || (config.ForceUpdate))
                    {
                        needingUpdate.Add(externalObject);
                    }
                }
            }

            // Find schools that are no longer in the database that could potentially be cleaned up
            if (config.AllowRemovals)
            {
                List <int> foundIDs = externalRepository.GetAllIDs();
                foreach (AbsenceReason internalObject in internalRepository.GetAll())
                {
                    if (!foundIDs.Contains(internalObject.ID))
                    {
                        noLongerExistsInExternalSystem.Add(internalObject);
                    }
                }
            }

            Log("Found " + previouslyUnknown.Count() + " previously unknown");
            Log("Found " + needingUpdate.Count() + " with updates");
            Log("Found " + noLongerExistsInExternalSystem.Count() + " not in external database");

            // Commit these changes to the database
            if (previouslyUnknown.Count > 0)
            {
                if (config.AllowAdds)
                {
                    Log(" > Adding " + previouslyUnknown.Count() + " new objects");
                    internalRepository.Add(previouslyUnknown);
                }
                else
                {
                    Log(" > Not allowed to add, skipping " + previouslyUnknown.Count() + " adds");
                }
            }


            if (needingUpdate.Count > 0)
            {
                if (config.AllowUpdates)
                {
                    Log(" > Updating " + needingUpdate.Count() + " objects");
                    internalRepository.Update(needingUpdate);
                }
                else
                {
                    Log(" > Not allowed to do updates, skipping " + needingUpdate.Count() + " updates");
                }
            }

            if (noLongerExistsInExternalSystem.Count > 0)
            {
                if (config.AllowRemovals)
                {
                    Log(" > If removals were implemented, we would remove " + noLongerExistsInExternalSystem.Count() + " objects here");
                }
                else
                {
                    Log(" > Not allowed to remove, skipping " + noLongerExistsInExternalSystem.Count() + " removals");
                }
            }
        }