Exemplo n.º 1
0
        void IInscriptionService.ValidateInscription(Guid code, string login, string pwdHash)
        {
            IDataManager dm = EntityManager.FromDataBaseService(ServiceName.MyDataService);

            QueryCriteria queryCriteria = new QueryCriteria(User.Fields.VerificationCode, ComparisonOperator.Equal, code);

            queryCriteria = queryCriteria.AND(new QueryCriteria(User.Fields.Email, ComparisonOperator.Equal, login.ToLower().Trim()));

            List <User> users = dm.GetEntities <User>(queryCriteria);

            if (users.Count == 1)
            {
                User user = users[0];

                user.Password         = pwdHash;
                user.Status           = EnumUserStatus.Valid;
                user.VerificationCode = null;

                dm.SaveTransactional();
            }
        }
Exemplo n.º 2
0
        //[PrincipalPermission(SecurityAction.Demand, Authenticated = true)]
        //DataSet ITrace.GetTrace(Date dateStart, Date dateEnd)
        //{
        //    IDataManager dm = EntityManager.FromDataBaseService(DataServiceName);

        //    var root = GetRoot(dm, true);

        //    IEntityManager em = dm as IEntityManager;

        //    TimeSpan timeSpan = dateEnd - dateStart;

        //    foreach (Events events in em.GetAllInstances<Events>())
        //    {
        //        string dayStart = TraceService.GetTimeTagKey(root.Id, events.Id, dateStart);//.Substring(0, 11).PadRight(6, '0');
        //        string dayEnd = TraceService.GetTimeTagKey(root.Id, events.Id, dateEnd.DateTime.AddDays(1)); //.Substring(0, 11).PadRight(6, '0');
        //        QueryCriteria qcDay = new QueryCriteria(Day.Fields.Id, ComparisonOperator.GreaterOrEquals, dayStart);
        //        qcDay = qcDay.AND(new QueryCriteria(Day.Fields.Id, ComparisonOperator.LessOrEquals, dayEnd));

        //        List<Day> tagDays = dm.GetEntities<Day>(qcDay);

        //        foreach (Day d in tagDays)
        //        {
        //            em.AssociateInstance<EventsDay>(events, d);
        //        }
        //    }

        //    dm.Data.AcceptChanges();

        //    return dm.Data;
        //}

        DataSet ITrace.GetEventsHistory(Guid eventsId, Date dateStart, Date dateEnd, EnumFrequency frequency)
        {
            IDataManager dm = EntityManager.FromDataBaseService(DataServiceName);

            var root = GetRoot(dm, false);

            IEntityManager em = dm as IEntityManager;

            DateTime dateEndTomorrow = dateEnd.DateTime.AddDays(1);

            Events events = dm.GetEntity <Events>(eventsId);

            string dayStart = TraceService.GetTimeIdFromDate(root.Id, events.Id, dateStart, TraceService.ExtractFormatDateDay);
            string dayEnd   = TraceService.GetTimeIdFromDate(root.Id, events.Id, dateEndTomorrow, TraceService.ExtractFormatDateDay);

            string weekStart = TraceService.GetTimeIdFromDate(root.Id, events.Id, dateStart, TraceService.ExtractFormatDateWeek);
            string weekEnd   = TraceService.GetTimeIdFromDate(root.Id, events.Id, dateEndTomorrow, TraceService.ExtractFormatDateWeek);

            string monthStart = TraceService.GetTimeIdFromDate(root.Id, events.Id, dateStart, TraceService.ExtractFormatDateMonth);
            string monthEnd   = TraceService.GetTimeIdFromDate(root.Id, events.Id, dateEndTomorrow, TraceService.ExtractFormatDateMonth);

            QueryCriteria qcMonth = new QueryCriteria(Month.Fields.Id, ComparisonOperator.GreaterOrEquals, monthStart);

            qcMonth = qcMonth.AND(new QueryCriteria(Month.Fields.Id, ComparisonOperator.LessOrEquals, monthEnd));

            List <Month> tagMonths = dm.GetEntities <Month>(qcMonth);

            foreach (Month m in tagMonths)
            {
                em.AssociateInstance <EventsMonth>(events, m);
            }

            QueryCriteria qcWeek = new QueryCriteria(Month.Fields.Id, ComparisonOperator.GreaterOrEquals, weekStart);

            qcWeek = qcWeek.AND(new QueryCriteria(Month.Fields.Id, ComparisonOperator.LessOrEquals, weekEnd));

            List <Week> tagWeeks = dm.GetEntities <Week>(qcWeek);

            foreach (Week w in tagWeeks)
            {
                em.AssociateInstance <EventsWeek>(events, w);
            }

            QueryCriteria qcDay = new QueryCriteria(Day.Fields.Id, ComparisonOperator.GreaterOrEquals, dayStart);

            qcDay = qcDay.AND(new QueryCriteria(Day.Fields.Id, ComparisonOperator.LessOrEquals, dayEnd));

            List <Day> days = dm.GetEntities <Day>(qcDay);

            foreach (Day d in days)
            {
                em.AssociateInstance <EventsDay>(events, d);
            }

            DateTime temp = dateStart.DateTime;

            TimeSpan ts = new Date(dateEndTomorrow) - dateStart;

            for (var i = 0; i < ts.Days; i++)
            {
                string tempDayId = TraceService.GetTimeIdFromDate(root.Id, events.Id, temp, TraceService.ExtractFormatDateDay);

                if (!events.Day.Exists(item => item.Id == tempDayId))
                {
                    Day tempTagDay = em.CreateInstance <Day>();
                    tempTagDay.Id         = tempDayId;
                    tempTagDay.TimeKey    = tempDayId.Split('|')[2]; //TraceService.GetTimeKey(temp);
                    tempTagDay.DatePeriod = temp.AddHours(12);
                    em.AssociateInstance <EventsDay>(events, tempTagDay);
                }

                string tempWeekId = TraceService.GetTimeIdFromDate(root.Id, events.Id, temp, TraceService.ExtractFormatDateWeek);

                if (!events.Week.Exists(item => item.Id == tempWeekId))
                {
                    Week tempTagWeek = em.CreateInstance <Week>();
                    tempTagWeek.Id         = tempWeekId;
                    tempTagWeek.TimeKey    = tempWeekId.Split('|')[2]; //TraceService.GetTimeKey(temp);
                    tempTagWeek.DatePeriod = temp.AddHours(12);
                    em.AssociateInstance <EventsWeek>(events, tempTagWeek);
                }

                string tempMonthId = TraceService.GetTimeIdFromDate(root.Id, events.Id, temp, TraceService.ExtractFormatDateMonth);

                if (!events.Month.Exists(item => item.Id == tempMonthId))
                {
                    Month tempTagMonth = em.CreateInstance <Month>();
                    tempTagMonth.Id         = tempMonthId;
                    tempTagMonth.TimeKey    = tempMonthId.Split('|')[2]; //TraceService.GetTimeKey(temp);
                    tempTagMonth.DatePeriod = temp.AddHours(12);
                    em.AssociateInstance <EventsMonth>(events, tempTagMonth);
                }

                temp = temp.AddDays(1);
            }

            dm.Data.AcceptChanges();

            return(dm.Data);
        }