Example #1
0
        public override string CreateExpiredJob(
            Job job,
            IDictionary <string, string> parameters,
            DateTime createdAt,
            TimeSpan expireIn)
        {
            var invocationData = InvocationData.Serialize(job);

            var jobModel = new JobModel();

            _storage.ObjectRepository.Add(jobModel);
            jobModel.InvocationData = JobHelper.ToJson(invocationData);
            jobModel.Arguments      = invocationData.Arguments;
            jobModel.CreatedAt      = createdAt;
            jobModel.ExpireAt       = createdAt.Add(expireIn);

            var jobId = jobModel.Id;

            foreach (var parameter in parameters)
            {
                var jpm = new JobParameterModel(jobId, parameter.Key)
                {
                    Value = parameter.Value
                };
                _storage.ObjectRepository.Add(jpm);
            }

            return(jobId.ToString());
        }
        /// <summary>
        ///		Convierte una fecha
        /// </summary>
        private void ConvertDate(MLNode nodeML, JobParameterModel parameter)
        {
            DateTime date = DateTime.Now.Date;

            // Asigna los valores iniciales
            parameter.DateMode  = nodeML.Attributes[TagComputeMode].Value.GetEnum(JobParameterModel.ComputeDateMode.Today);
            parameter.Interval  = nodeML.Attributes[TagInterval].Value.GetEnum(JobParameterModel.IntervalType.Day);
            parameter.Increment = nodeML.Attributes[TagIncrement].Value.GetInt(0);
            parameter.Mode      = nodeML.Attributes[TagMode].Value.GetEnum(JobParameterModel.IntervalMode.Unknown);
            // Se recoge la fecha (si se ha introducido alguna)
            if (parameter.DateMode == JobParameterModel.ComputeDateMode.Fixed)
            {
                date = nodeML.Attributes[TagValue].Value.GetDateTime(DateTime.Now);
            }
            // Ajusta el valor con los parámetros del XML
            if (parameter.Increment != 0)
            {
                switch (parameter.Interval)
                {
                case JobParameterModel.IntervalType.Day:
                    date = date.AddDays(parameter.Increment);
                    break;

                case JobParameterModel.IntervalType.Month:
                    date = date.AddMonths(parameter.Increment);
                    break;

                case JobParameterModel.IntervalType.Year:
                    date = date.AddYears(parameter.Increment);
                    break;
                }
            }
            // Ajusta la fecha
            switch (parameter.Mode)
            {
            case JobParameterModel.IntervalMode.PreviousMonday:
                date = GetPreviousMonday(date);
                break;

            case JobParameterModel.IntervalMode.NextMonday:
                date = GetNextMonday(date);
                break;

            case JobParameterModel.IntervalMode.MonthStart:
                date = GetFirstMonthDay(date);
                break;

            case JobParameterModel.IntervalMode.MonthEnd:
                date = GetLastMonthDay(date);
                break;
            }
            // Asigna la fecha calculada
            parameter.Value = date;
        }
Example #3
0
        public override void SetJobParameter(string id, string name, string value)
        {
            var jobId = Guid.Parse(id);

            var jobParam = _storage.ObjectRepository.Set <JobParameterModel>()
                           .FirstOrDefault(v => v.JobId == jobId && v.Name == name);

            if (jobParam == null)
            {
                jobParam = new JobParameterModel(jobId, name);
                _storage.ObjectRepository.Add(jobParam);
            }

            jobParam.Value = value;
        }
        /// <summary>
        ///		Carga una colección de parámetros
        /// </summary>
        internal NormalizedDictionary <JobParameterModel> LoadParameters(MLNode rootML)
        {
            NormalizedDictionary <JobParameterModel> parameters = new NormalizedDictionary <JobParameterModel>();

            // Carga los parámetros
            foreach (MLNode nodeML in rootML.Nodes)
            {
                if (nodeML.Name == TagParameter)
                {
                    JobParameterModel parameter = LoadParameter(nodeML);

                    parameters.Add(parameter.Key, parameter);
                }
            }
            // Devuelve la colección de parámetros
            return(parameters);
        }
        /// <summary>
        ///		Carga un parámetro
        /// </summary>
        internal JobParameterModel LoadParameter(MLNode rootML)
        {
            JobParameterModel parameter = new JobParameterModel();

            // Asigna el tipo
            parameter.Key  = rootML.Attributes[TagKey].Value.TrimIgnoreNull();
            parameter.Type = rootML.Attributes[TagType].Value.GetEnum(JobParameterModel.ParameterType.Unknown);
            // Obtiene el valor
            switch (parameter.Type)
            {
            case JobParameterModel.ParameterType.Numeric:
                parameter.Value = rootML.Attributes[TagValue].Value.GetDouble(0);
                break;

            case JobParameterModel.ParameterType.Boolean:
                parameter.Value = rootML.Attributes[TagValue].Value.GetBool();
                break;

            case JobParameterModel.ParameterType.DateTime:
                ConvertDate(rootML, parameter);
                break;

            default:
                if (string.IsNullOrWhiteSpace(rootML.Attributes[TagValue].Value))
                {
                    parameter.Value = rootML.Value.TrimIgnoreNull();
                }
                else
                {
                    parameter.Value = rootML.Attributes[TagValue].Value.TrimIgnoreNull();
                }
                break;
            }
            // Devuelve el parámetro
            return(parameter);
        }