Esempio n. 1
0
        public async Task <ActionResult> Edit(int id, ToDoStatusViewModel item)
        {
            try
            {
                var user = await GetCurrentUserAsync();

                var todoItem = new ToDoItem()
                {
                    Id                = id,
                    Title             = item.Title,
                    ToDoStatusId      = item.ToDoStatusId,
                    ApplicationUserId = user.Id
                };

                _context.ToDoItem.Update(todoItem);
                await _context.SaveChangesAsync();


                return(RedirectToAction(nameof(Index)));
            }
            catch (Exception ex)
            {
                return(View());
            }
        }
        public ToDoStatusResponse Create(ToDoStatusViewModel toDoStatus)
        {
            ToDoStatusResponse response = new ToDoStatusResponse();

            using (SqliteConnection db = new SqliteConnection(SQLiteHelper.SqLiteTableName))
            {
                db.Open();

                SqliteCommand insertCommand = db.CreateCommand();
                insertCommand.CommandText = SqlCommandInsertPart;

                try
                {
                    insertCommand = AddCreateParameters(insertCommand, toDoStatus);
                    insertCommand.ExecuteNonQuery();
                }
                catch (SqliteException error)
                {
                    MainWindow.ErrorMessage = error.Message;
                    response.Success        = false;
                    response.Message        = error.Message;
                    return(response);
                }
                db.Close();

                response.Success = true;
                return(response);
            }
        }
        public ToDoStatusListResponse GetToDoStatusesByPage(int companyId, ToDoStatusViewModel toDoStatusSearchObject, int currentPage = 1, int itemsPerPage = 50)
        {
            ToDoStatusListResponse     response     = new ToDoStatusListResponse();
            List <ToDoStatusViewModel> toDoStatuses = new List <ToDoStatusViewModel>();

            using (SqliteConnection db = new SqliteConnection("Filename=SirmiumERPGFC.db"))
            {
                db.Open();
                try
                {
                    SqliteCommand selectCommand = new SqliteCommand(
                        SqlCommandSelectPart +
                        "FROM ToDoStatuses " +
                        "WHERE (@Name IS NULL OR @Name = '' OR Name LIKE @Name) " +
                        "AND CompanyId = @CompanyId " +
                        "ORDER BY IsSynced, ServerId " +
                        "LIMIT @ItemsPerPage OFFSET @Offset;", db);

                    selectCommand.Parameters.AddWithValue("@Name", ((object)toDoStatusSearchObject.Search_Name) != null ? "%" + toDoStatusSearchObject.Search_Name + "%" : "");
                    selectCommand.Parameters.AddWithValue("@CompanyId", companyId);
                    selectCommand.Parameters.AddWithValue("@ItemsPerPage", itemsPerPage);
                    selectCommand.Parameters.AddWithValue("@Offset", (currentPage - 1) * itemsPerPage);

                    SqliteDataReader query = selectCommand.ExecuteReader();

                    while (query.Read())
                    {
                        toDoStatuses.Add(Read(query));
                    }

                    selectCommand = new SqliteCommand(
                        "SELECT Count(*) " +
                        "FROM ToDoStatuses " +
                        "WHERE (@Name IS NULL OR @Name = '' OR Name LIKE @Name) " +
                        "AND CompanyId = @CompanyId;", db);

                    selectCommand.Parameters.AddWithValue("@Name", ((object)toDoStatusSearchObject.Search_Name) != null ? "%" + toDoStatusSearchObject.Search_Name + "%" : "");
                    selectCommand.Parameters.AddWithValue("@CompanyId", companyId);

                    query = selectCommand.ExecuteReader();

                    if (query.Read())
                    {
                        response.TotalItems = query.GetInt32(0);
                    }
                }
                catch (SqliteException error)
                {
                    MainWindow.ErrorMessage = error.Message;
                    response.Success        = false;
                    response.Message        = error.Message;
                    response.ToDoStatuses   = new List <ToDoStatusViewModel>();
                    return(response);
                }
                db.Close();
            }
            response.Success      = true;
            response.ToDoStatuses = toDoStatuses;
            return(response);
        }
        private static void OnCurrentToDoStatusPropertyChanged(DependencyObject source, DependencyPropertyChangedEventArgs e)
        {
            ToDoStatusPopup     popup      = source as ToDoStatusPopup;
            ToDoStatusViewModel ToDoStatus = (ToDoStatusViewModel)e.NewValue;

            popup.txtToDoStatus.Text = ToDoStatus != null ? ToDoStatus.Name + ")" : "";
        }
Esempio n. 5
0
        // GET: TodoItems/Edit/5
        public async Task <ActionResult> Edit(int id)
        {
            var allStatuses = await _context.ToDoStatus
                              .ToListAsync();

            var toDoItem = await _context.ToDoItem.FirstOrDefaultAsync(ti => ti.Id == id);

            var user = await GetCurrentUserAsync();

            var todoItem = _context.ToDoItem
                           .FirstOrDefault(ti => ti.Id == id);

            var viewModel = new ToDoStatusViewModel()
            {
                Title             = todoItem.Title,
                ToDoStatusId      = todoItem.ToDoStatusId,
                ToDoStatusOptions = allStatuses
                                    .Select(td => new SelectListItem()
                {
                    Text  = td.Title,
                    Value = td.Id.ToString()
                }).ToList()
            };

            if (toDoItem.ApplicationUserId != user.Id)
            {
                return(NotFound());
            }

            return(View(viewModel));
        }
Esempio n. 6
0
        private void btnAdd_Click(object sender, RoutedEventArgs e)
        {
            ToDoStatusViewModel ToDoStatus = new ToDoStatusViewModel();

            ToDoStatus.Identifier = Guid.NewGuid();

            ToDoStatus_AddEdit addEditForm = new ToDoStatus_AddEdit(ToDoStatus, true);

            addEditForm.ToDoStatusCreatedUpdated += new ToDoStatusHandler(SyncData);
            FlyoutHelper.OpenFlyout(this, (string)Application.Current.FindResource("Podaci_o_statusu"), 95, addEditForm);
        }
        public ToDoStatus_AddEdit(ToDoStatusViewModel ToDoStatusViewModel, bool isCreateProcess, bool isPopup = false)
        {
            ToDoStatusService = DependencyResolver.Kernel.Get <IToDoStatusService>();

            InitializeComponent();

            this.DataContext = this;

            CurrentToDoStatus = ToDoStatusViewModel;
            IsCreateProcess   = isCreateProcess;
            IsPopup           = isPopup;
        }
        public SqliteCommand AddCreateParameters(SqliteCommand insertCommand, ToDoStatusViewModel toDoStatus)
        {
            insertCommand.Parameters.AddWithValue("@ServerId", toDoStatus.Id);
            insertCommand.Parameters.AddWithValue("@Identifier", toDoStatus.Identifier);
            insertCommand.Parameters.AddWithValue("@Code", ((object)toDoStatus.Code) ?? DBNull.Value);
            insertCommand.Parameters.AddWithValue("@Name", ((object)toDoStatus.Name) ?? DBNull.Value);
            insertCommand.Parameters.AddWithValue("@IsSynced", toDoStatus.IsSynced);
            insertCommand.Parameters.AddWithValue("@UpdatedAt", ((object)toDoStatus.UpdatedAt) ?? DBNull.Value);
            insertCommand.Parameters.AddWithValue("@CreatedById", MainWindow.CurrentUser.Id);
            insertCommand.Parameters.AddWithValue("@CreatedByName", MainWindow.CurrentUser.FirstName + " " + MainWindow.CurrentUser.LastName);
            insertCommand.Parameters.AddWithValue("@CompanyId", MainWindow.CurrentCompany.Id);
            insertCommand.Parameters.AddWithValue("@CompanyName", MainWindow.CurrentCompany.CompanyName);

            return(insertCommand);
        }
        private ToDoStatusViewModel Read(SqliteDataReader query)
        {
            int counter = 0;
            ToDoStatusViewModel dbEntry = new ToDoStatusViewModel();

            dbEntry.Id         = SQLiteHelper.GetInt(query, ref counter);
            dbEntry.Identifier = SQLiteHelper.GetGuid(query, ref counter);
            dbEntry.Code       = SQLiteHelper.GetString(query, ref counter);
            dbEntry.Name       = SQLiteHelper.GetString(query, ref counter);
            dbEntry.IsSynced   = SQLiteHelper.GetBoolean(query, ref counter);
            dbEntry.UpdatedAt  = SQLiteHelper.GetDateTime(query, ref counter);
            dbEntry.CreatedBy  = SQLiteHelper.GetCreatedBy(query, ref counter);
            dbEntry.Company    = SQLiteHelper.GetCompany(query, ref counter);

            return(dbEntry);
        }
Esempio n. 10
0
        // GET: TodoItems/Create
        public async Task <ActionResult> Create()
        {
            var allStatuses = await _context.ToDoStatus
                              .Select(td => new SelectListItem()
            {
                Text  = td.Title,
                Value = td.Id.ToString()
            })
                              .ToListAsync();

            var viewModel = new ToDoStatusViewModel();

            viewModel.ToDoStatusOptions = allStatuses;

            return(View(viewModel));
        }
        public ToDoStatusResponse Create(ToDoStatusViewModel ToDoStatus)
        {
            ToDoStatusResponse response = new ToDoStatusResponse();

            try
            {
                response = WpfApiHandler.SendToApi <ToDoStatusViewModel, ToDoStatusResponse>(ToDoStatus, "Create");
            }
            catch (Exception ex)
            {
                response.ToDoStatus = new ToDoStatusViewModel();
                response.Success    = false;
                response.Message    = ex.Message;
            }

            return(response);
        }
Esempio n. 12
0
 public static ToDoStatusViewModel GetToDoStatus(SqliteDataReader query, ref int counter)
 {
     if (query.IsDBNull(counter))
     {
         counter += 4;
         return(null);
     }
     else
     {
         var viewModel = new ToDoStatusViewModel();
         viewModel.Id         = query.GetInt32(counter++);
         viewModel.Identifier = query.GetGuid(counter++);
         viewModel.Code       = query.IsDBNull(counter++) ? "" : query.GetString(counter - 1);
         viewModel.Name       = query.IsDBNull(counter++) ? "" : query.GetString(counter - 1);
         return(viewModel);
     };
 }
Esempio n. 13
0
        public static ToDoStatus ConvertToToDoStatus(this ToDoStatusViewModel toDoStatusViewModel)
        {
            ToDoStatus toDoStatus = new ToDoStatus()
            {
                Id         = toDoStatusViewModel.Id,
                Identifier = toDoStatusViewModel.Identifier,
                Code       = toDoStatusViewModel.Code,
                Name       = toDoStatusViewModel.Name,

                CreatedById = toDoStatusViewModel.CreatedBy?.Id ?? null,
                CompanyId   = toDoStatusViewModel.Company?.Id ?? null,

                CreatedAt = toDoStatusViewModel.CreatedAt,
                UpdatedAt = toDoStatusViewModel.UpdatedAt
            };

            return(toDoStatus);
        }
Esempio n. 14
0
        public static ToDoStatusViewModel ConvertToToDoStatusViewModelLite(this ToDoStatus toDoStatus)
        {
            ToDoStatusViewModel toDoStatusViewModel = new ToDoStatusViewModel()
            {
                Id         = toDoStatus.Id,
                Identifier = toDoStatus.Identifier,
                Code       = toDoStatus.Code,
                Name       = toDoStatus.Name,

                IsActive = toDoStatus.Active,

                UpdatedAt = toDoStatus.UpdatedAt,
                CreatedAt = toDoStatus.CreatedAt
            };


            return(toDoStatusViewModel);
        }
        public ToDoStatusResponse Delete(Guid identifier)
        {
            ToDoStatusResponse response = new ToDoStatusResponse();

            try
            {
                ToDoStatusViewModel ToDoStatus = new ToDoStatusViewModel();
                ToDoStatus.Identifier = identifier;
                response = WpfApiHandler.SendToApi <ToDoStatusViewModel, ToDoStatusResponse>(ToDoStatus, "Delete");
            }
            catch (Exception ex)
            {
                response.ToDoStatus = new ToDoStatusViewModel();
                response.Success    = false;
                response.Message    = ex.Message;
            }

            return(response);
        }
        public ToDoStatusResponse Create(ToDoStatusViewModel re)
        {
            ToDoStatusResponse response = new ToDoStatusResponse();

            try
            {
                ToDoStatus addedToDoStatus = unitOfWork.GetToDoStatusRepository().Create(re.ConvertToToDoStatus());

                unitOfWork.Save();

                response.ToDoStatus = addedToDoStatus.ConvertToToDoStatusViewModel();
                response.Success    = true;
            }
            catch (Exception ex)
            {
                response.ToDoStatus = new ToDoStatusViewModel();
                response.Success    = false;
                response.Message    = ex.Message;
            }

            return(response);
        }
Esempio n. 17
0
        public JsonResult Delete([FromBody] ToDoStatusViewModel Status)
        {
            ToDoStatusResponse response = new ToDoStatusResponse();

            try
            {
                response = this.ToDoStatusService.Delete(Status.Identifier);
            }
            catch (Exception ex)
            {
                response.Success = false;
                response.Message = ex.Message;
                Console.WriteLine(ex.Message);
            }

            JsonResult result = Json(response, new Newtonsoft.Json.JsonSerializerSettings()
            {
                Formatting            = Newtonsoft.Json.Formatting.Indented,
                ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize
            });

            return(result);
        }
        public ToDoStatusResponse GetToDoStatus(Guid identifier)
        {
            ToDoStatusResponse  response   = new ToDoStatusResponse();
            ToDoStatusViewModel toDoStatus = null;

            using (SqliteConnection db = new SqliteConnection("Filename=SirmiumERPGFC.db"))
            {
                db.Open();
                try
                {
                    SqliteCommand selectCommand = new SqliteCommand(
                        SqlCommandSelectPart +
                        "FROM ToDoStatuses " +
                        "WHERE Identifier = @Identifier;", db);
                    selectCommand.Parameters.AddWithValue("@Identifier", identifier);

                    SqliteDataReader query = selectCommand.ExecuteReader();

                    if (query.Read())
                    {
                        toDoStatus = Read(query);
                    }
                }
                catch (SqliteException error)
                {
                    MainWindow.ErrorMessage = error.Message;
                    response.Success        = false;
                    response.Message        = error.Message;
                    response.ToDoStatus     = new ToDoStatusViewModel();
                    return(response);
                }
                db.Close();
            }
            response.Success    = true;
            response.ToDoStatus = toDoStatus;
            return(response);
        }
        private void btnSubmit_Click(object sender, RoutedEventArgs e)
        {
            #region Validation

            if (String.IsNullOrEmpty(CurrentToDoStatus.Name))
            {
                MainWindow.WarningMessage = ((string)Application.Current.FindResource("Obavezno_polje_naziv"));
                return;
            }

            #endregion

            Thread th = new Thread(() =>
            {
                SubmitButtonContent = ((string)Application.Current.FindResource("Čuvanje_u_tokuTriTacke"));
                SubmitButtonEnabled = false;

                CurrentToDoStatus.IsSynced = false;
                CurrentToDoStatus.Company  = new CompanyViewModel()
                {
                    Id = MainWindow.CurrentCompanyId
                };
                CurrentToDoStatus.CreatedBy = new UserViewModel()
                {
                    Id = MainWindow.CurrentUserId
                };

                ToDoStatusResponse response = new ToDoStatusSQLiteRepository().Delete(CurrentToDoStatus.Identifier);
                response = new ToDoStatusSQLiteRepository().Create(CurrentToDoStatus);
                if (!response.Success)
                {
                    MainWindow.ErrorMessage = ((string)Application.Current.FindResource("Greška_kod_čuvanja_na_serveruUzvičnik"));
                    SubmitButtonContent     = ((string)Application.Current.FindResource("Proknjiži"));
                    SubmitButtonEnabled     = true;
                    return;
                }

                response = ToDoStatusService.Create(CurrentToDoStatus);
                if (!response.Success)
                {
                    MainWindow.ErrorMessage = ((string)Application.Current.FindResource("Podaci_su_sačuvani_u_lokaluUzvičnikTačka_Greška_kod_čuvanja_na_serveruUzvičnik")) + response.Message;
                    SubmitButtonContent     = ((string)Application.Current.FindResource("Proknjiži"));
                    SubmitButtonEnabled     = true;
                }

                if (response.Success)
                {
                    MainWindow.SuccessMessage = ((string)Application.Current.FindResource("Podaci_su_uspešno_sačuvaniUzvičnik"));
                    SubmitButtonContent       = ((string)Application.Current.FindResource("Proknjiži"));
                    SubmitButtonEnabled       = true;

                    ToDoStatusCreatedUpdated();

                    if (IsCreateProcess)
                    {
                        CurrentToDoStatus            = new ToDoStatusViewModel();
                        CurrentToDoStatus.Identifier = Guid.NewGuid();

                        Application.Current.Dispatcher.BeginInvoke(
                            System.Windows.Threading.DispatcherPriority.Normal,
                            new Action(() =>
                        {
                            txtName.Focus();
                        })
                            );
                    }
                    else
                    {
                        Application.Current.Dispatcher.BeginInvoke(
                            System.Windows.Threading.DispatcherPriority.Normal,
                            new Action(() =>
                        {
                            if (IsPopup)
                            {
                                FlyoutHelper.CloseFlyoutPopup(this);
                            }
                            else
                            {
                                FlyoutHelper.CloseFlyout(this);
                            }
                        })
                            );
                    }
                }
            });
            th.IsBackground = true;
            th.Start();
        }