public void AddOffline(StoreOfflineModel model, string userId)
        {
            var offline = new FranchiseStoreOffLine
            {
                DateTimeStart          = model.UtcStartDateTime,
                Duration               = model.Duration,
                UserInsId              = userId,
                IsObsolete             = false,
                FranchiseStoreId       = model.FranchiseStoreId,
                IsUndefinedOfflineTime = model.IsUndefinedOfflineTime
            };

            offline.DateTimeEnd = offline.DateTimeStart.AddMinutes(offline.Duration);

            DbEntities.FranchiseStoreOffLine.Add(offline);
            DbEntities.SaveChanges();
        }
예제 #2
0
        public ActionResult Upsert(int storeId, int?id)
        {
            StoreOfflineModel model = null;

            try
            {
                using (var repository = new StoreRepository())
                {
                    model = repository.FindStoreOfflineModelById(storeId, id);
                    ViewBag.StartDateTime = id.HasValue ? model.UtcStartDateTimeSaved.ToString(SharedConstants.DATE_TIME_FORMAT) : DateTime.UtcNow.ToString(SharedConstants.DATE_TIME_FORMAT);
                    ViewBag.Model         = JsonConvert.SerializeObject(model);
                }
            }
            catch (Exception ex)
            {
                SharedLogger.LogError(ex, id);
            }
            return(View(model));
        }
예제 #3
0
        public ActionResult DoUpsert(StoreOfflineModel model)
        {
            try
            {
                if (ModelState.IsValid == false)
                {
                    return(Json(new ResponseMessageModel
                    {
                        HasError = true,
                        Title = ResShared.TITLE_REGISTER_FAILED,
                        Message = ResShared.ERROR_INVALID_MODEL
                    }));
                }

                var response = new ResponseMessageModel();
                using (var repository = new StoreRepository())
                {
                    if (model.FranchiseStoreOffLineId > EntityConstants.NO_VALUE)
                    {
                        repository.UpdateOffline(model, response, User.Identity.GetUserId());
                    }
                    else
                    {
                        repository.AddOffline(model, User.Identity.GetUserId());
                    }
                }

                response.HasError = false;
                return(Json(response));
            }
            catch (Exception ex)
            {
                SharedLogger.LogError(ex);
                return(Json(new ResponseMessageModel
                {
                    HasError = true,
                    Title = ResShared.TITLE_REGISTER_FAILED,
                    Message = ResShared.ERROR_UNKOWN
                }));
            }
        }
        public void UpdateOffline(StoreOfflineModel model, ResponseMessageModel response, string userId)
        {
            var offline = DbEntities.FranchiseStoreOffLine.FirstOrDefault(
                e => e.FranchiseStoreOffLineId == model.FranchiseStoreOffLineId);

            if (offline == null)
            {
                response.HasError = true;
                response.Message  = "No existe registro para actualizar";
                return;
            }

            offline.DateTimeStart          = model.UtcStartDateTime;
            offline.Duration               = model.Duration;
            offline.DateTimeEnd            = offline.DateTimeStart.AddMinutes(offline.Duration);
            offline.UserUpdId              = userId;
            offline.IsUndefinedOfflineTime = model.IsUndefinedOfflineTime;
            offline.IsObsolete             = false;

            DbEntities.SaveChanges();
        }