public IActionResult AddLine(Guid id, [FromBody] DocumentLine documentLine)
{
logger.LogInformation($"Looking for timesheet {id}");
Timecard timecard = repository.Find(id);
if (timecard != null)
{
if (timecard.Status != TimecardStatus.Draft)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
var annotatedLine = timecard.AddLine(documentLine);
repository.Update(timecard);
return(Ok(annotatedLine));
}
else
{
return(NotFound());
}
}
public IActionResult UpdateLine(Guid id, [FromBody] DocumentLine documentLine, Guid lineId)
{
logger.LogInformation($"Looking for timesheet {id} and line {lineId}");
Timecard timecard = repository.Find(id);
if (timecard != null)
{
if (timecard.Status != TimecardStatus.Draft)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
//update line
if (timecard.HasLine(lineId))
{
var updatedLine = timecard.UpdateLine(documentLine, lineId);
repository.Update(timecard);
return(Ok(updatedLine));
}
}
return(NotFound());
}
public IActionResult GetApproval(string id)
{
Timecard timecard = Database.Find(id);
if (timecard != null)
{
if (timecard.Status == TimecardStatus.Approved)
{
var transition = timecard.Transitions
.Where(t => t.TransitionedTo == TimecardStatus.Approved)
.OrderByDescending(t => t.OccurredAt)
.FirstOrDefault();
return(Ok(transition));
}
else
{
return(StatusCode(409, new MissingTransitionError()
{
}));
}
}
else
{
return(NotFound());
}
}
public IActionResult DeleteLine(string id, [FromBody] Remove delete)
{
Timecard timecard = Database.Find(id);
if (timecard == null)
{
return(NotFound());
}
if (timecard.Status != TimecardStatus.Cancelled && timecard.Status != TimecardStatus.Draft)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
if (timecard.Resource != delete.Resource)
{
return(StatusCode(409, new EmptyTimecardError()
{
}));
}
Database.Delete(id);
return(Ok());
}
public IActionResult Cancel(string id, [FromBody] Cancellation cancellation)
{
Timecard timecard = Database.Find(id);
if (timecard != null)
{
if (timecard.Status != TimecardStatus.Draft && timecard.Status != TimecardStatus.Submitted)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
if (timecard.Resource != cancellation.Resource)
{
return(StatusCode(409, new EmptyTimecardError()
{
}));
}
var transition = new Transition(cancellation, TimecardStatus.Cancelled);
timecard.Transitions.Add(transition);
return(Ok(transition));
}
else
{
return(NotFound());
}
}
public IActionResult Approve(string id, [FromBody] Approval approval)
{
Timecard timecard = Database.Find(id);
if (timecard != null)
{
if (timecard.Status != TimecardStatus.Submitted)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
if (timecard.Resource == approval.Resource)
{
return(StatusCode(409, new EmptyTimecardError()
{
}));
}
var transition = new Transition(approval, TimecardStatus.Approved);
timecard.Transitions.Add(transition);
return(Ok(transition));
}
else
{
return(NotFound());
}
}
public IActionResult Delete(Guid id, [FromQuery] int reqid)
{
logger.LogInformation($"Looking for timesheet {id}");
Timecard timecard = repository.Find(id);
if (timecard == null)
{
return(NotFound());
}
if (reqid != timecard.Employee)
{
return(StatusCode(403, new TimecardPersonError()
{
}));
}
if (timecard.CanBeDeleted() == false)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
repository.Delete(id);
return(Ok());
}
public IActionResult GetApproval(Guid id)
{
logger.LogInformation($"Looking for timesheet {id}");
Timecard timecard = repository.Find(id);
if (timecard != null)
{
if (timecard.Status == TimecardStatus.Approved)
{
var transition = timecard.Transitions
.Where(t => t.TransitionedTo == TimecardStatus.Approved)
.OrderByDescending(t => t.OccurredAt)
.FirstOrDefault();
return(Ok(transition));
}
else
{
return(StatusCode(409, new MissingTransitionError()
{
}));
}
}
else
{
return(NotFound());
}
}
public IActionResult Reject(Guid id, [FromBody] Rejection rejection)
{
logger.LogInformation($"Looking for timesheet {id}");
Timecard timecard = repository.Find(id);
if (timecard != null)
{
if (timecard.Status != TimecardStatus.Submitted)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
var transition = new Transition(rejection, TimecardStatus.Rejected);
logger.LogInformation($"Adding rejection transition {transition}");
timecard.Transitions.Add(transition);
repository.Update(timecard);
return(Ok(transition));
}
else
{
return(NotFound());
}
}
public IActionResult DeleteLine(Guid id, Guid lineId, [FromQuery] int reqid)
{
logger.LogInformation($"Looking for timesheet {id}");
Timecard timecard = repository.Find(id);
if (timecard != null)
{
if (reqid != timecard.Employee)
{
return(StatusCode(403, new TimecardPersonError()
{
}));
}
if (timecard.Status != TimecardStatus.Draft)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
timecard.DeleteLine(lineId);
repository.Update(timecard);
return(Ok());
}
else
{
return(NotFound());
}
}
public IActionResult UpdateLine(Guid id, Guid lineId, [FromQuery] int reqid, [FromBody] JsonPatchDocument <TimecardLine> patchDocumnetLine)
{
logger.LogInformation($"Looking for timesheet {id}");
Timecard timecard = repository.Find(id);
if (timecard != null)
{
if (reqid != timecard.Employee)
{
return(StatusCode(403, new TimecardPersonError()
{
}));
}
if (timecard.Status != TimecardStatus.Draft)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
var annotatedLine = timecard.FindLine(lineId);
patchDocumnetLine.ApplyTo(annotatedLine, ModelState);
repository.Update(timecard);
return(Ok(annotatedLine));
}
else
{
return(NotFound());
}
}
public WorktaskViewModel GetWorkTaskViewModel(String worktaskID, String projectID, String timecardID)
{
if (!String.IsNullOrEmpty(worktaskID))
{
//wenn es bereits ein WorkTaskViewMOdel gibt und dies auch noch dem entspricht, was gefordert ist, dann wird auch nur dies zurückgeliefert (Werte sind noch die alten)
if (workTaskViewModel != null)
{
if (workTaskViewModel.WorktaskID == worktaskID)
{
return(workTaskViewModel);
}
}
WorkTask newWorkTask = (WorkTask)getDBObjectForID(DBObjects.Worktask, worktaskID);
if (newWorkTask == null)
{
if (timecardViewModel != null)
{
newWorkTask = new WorkTask()
{
WorkTaskID = worktaskID, DayDate = timecardViewModel.TimecardStartDate, Ident_WorkTask = HelperClass.GetIdentForWorktask(timecardViewModel.TimecardStartDate, ""), TimecardID = timecardViewModel.TimecardID, Timecard = (Timecard)getDBObjectForID(DBObjects.Timecard, timecardViewModel.TimecardID)
}
}
;
else
{
Timecard tmpTimecard = getTimecardForDate(DateTime.Now);
if (tmpTimecard != null)
{
timecardViewModel = new TimecardViewModel(tmpTimecard);
}
else
{
return(null);
}
newWorkTask = new WorkTask()
{
WorkTaskID = worktaskID, DayDate = DateTime.Now, Ident_WorkTask = HelperClass.GetIdentForWorktask(DateTime.Now, ""), Timecard = tmpTimecard, TimecardID = timecardViewModel.TimecardID
};
}
if (!String.IsNullOrEmpty(projectID))
{
var projectFromColl = from Project project in ProjectCollection
where project.ProjectID == projectID
select project;
if (projectFromColl.Count() == 1)
{
newWorkTask.Project = projectFromColl.Single();
}
}
}
workTaskViewModel = new WorktaskViewModel(newWorkTask);
}
return(workTaskViewModel);
}
public ActionResult ProcessSelectedTimecards(TimecardApprovalViewModel vm)
{
Guid userId = new Guid(User.Identity.GetUserId());
if (vm != null && vm.Timecards != null)
{
foreach (var item in vm.Timecards)
{
Timecard timecard = timecardService.GetById(item.Id);
Applicant employee = timecardService.GetEmployeeByTimecardId(timecard);
if (vm.ApprovalStatus == "Approve")
{
timecard.ApprovalStatus = "Approved";
timecard.Approved = true;
timecard.ApprovedDate = DateTime.Now;
//EmailTemplate template = SendGridEmailService.GetEmailTemplate("Timecard Approved");
string path = string.Empty;
//if (template.Active)
//{
// if (!string.IsNullOrWhiteSpace(employee.Email))
// {
// //SendGridEmailService.SendEmail(template, employee.Email, userId.ToString(), employee.FirstName, employee.LastName, "", path);
// }
// if (!string.IsNullOrWhiteSpace(employee.CellPhone))
// {
// //SMSService.SendSMS(template, employee.CellPhone, userId.ToString(), null);
// }
//}
}
else if (vm.ApprovalStatus == "Reject")
{
timecard.ApprovalStatus = "Rejected";
timecard.Approved = false;
timecard.LastRejectedDate = DateTime.Now;
//EmailTemplate template = SendGridEmailService.GetEmailTemplate("Timecard Rejected");
string path = string.Empty;
//if (template.Active)
//{
// if (!string.IsNullOrWhiteSpace(employee.Email))
// {
// //SendGridEmailService.SendEmail(template, employee.Email, userId.ToString(), employee.FirstName, employee.LastName, "", path);
// }
// if (!string.IsNullOrWhiteSpace(employee.CellPhone))
// {
// //SMSService.SendSMS(template, employee.CellPhone, userId.ToString(), null);
// }
//}
}
var errors = ModelState.Values.SelectMany(v => v.Errors);
// try / catch please
// put this in a try/catch
if (ModelState.IsValid)
{
timecardService.Update(timecard);
}
}
}
return(RedirectToAction("Index"));
}
public ActionResult DeleteConfirmed(int id)
{
Timecard timecard = db.Timecards.Find(id);
db.Timecards.Remove(timecard);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Create(Timecard timecard)
{
if (ModelState.IsValid)
{
timecardService.AddTimecard(timecard);
return(RedirectToAction("Index"));
}
return(View(timecard));
}
/// <summary>
/// Retrieves a timecard by its ID
/// </summary>
/// <param name="key">Primary key</param>
/// <returns>Timecard retrieved from database</returns>
public Timecard GetSpecificTimecard(int key)
{
var repo = _factory.Resolve <IRepository>();
var timecard = repo.GetTimecard(key);
_timecard = timecard
?? throw new TimecardNotFoundException();
return(_timecard);
}
public void SaveTimecardToDB(Timecard thisTimecard)
{
if (!dellAppDB.Timecards.Contains(thisTimecard))
{
dellAppDB.Timecards.InsertOnSubmit(thisTimecard);
}
dellAppDB.SubmitChanges();
}
public void Update(Timecard timecard)
{
using (var database = new LiteDatabase(DATABASE_FILE))
{
var timesheets = database.GetCollection <Timecard>("timesheets");
timesheets.Update(timecard);
}
}
//Path a entry in the line for the given line id from the specified timesheet
public IActionResult PatchLine(Guid id, Guid lineId, [FromBody] DocumentLine documentLine)
{
logger.LogInformation($"Looking for timesheet {id}");
logger.LogInformation($"Looking for Line {lineId}");
logger.LogInformation($"Looking for Doc Line {documentLine}");
Timecard timecard = repository.Find(id);
if (timecard != null)
{
if (timecard.Status != TimecardStatus.Draft)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
TimecardLine line = timecard.Lines
.FirstOrDefault(l => l.UniqueIdentifier == lineId);
if (line == null)
{
return(NotFound());
}
if (documentLine.Week != 0)
{
line.Week = documentLine.Week;
}
if (documentLine.Year != 0)
{
line.Year = documentLine.Year;
}
if (documentLine.Hours != 0.0)
{
line.Hours = documentLine.Hours;
}
if (documentLine.Day != DayOfWeek.Sunday)
{
line.Day = documentLine.Day;
}
if (documentLine.Project.Length != 0)
{
line.Project = documentLine.Project;
}
repository.Update(timecard);
return(Ok(line));
}
else
{
return(NotFound());
}
}
public TimecardViewModel(Timecard newTimecard)
{
thisTimecard = newTimecard;
timecardID = newTimecard.TimecardID;
IsClosed = newTimecard.IsComplete;
//TimecardEnabled = !newTimecard.IsComplete;
timecardName = newTimecard.TimecardName;
timecardStartDate = newTimecard.StartDate;
}
// -----------------------------------------------------
// Form -- Load Event Handler
private void TimecardForm_Load(object sender, EventArgs e)
{
_currentFormState = FormState.Loading;
//Cache all active tasks from the database
GetActiveTasks();
//Get a deep copy of active tasks in our filtered tasks
foreach (var task in _activeTasks)
{
_filteredTasks.Add(task);
}
// Get all timecards for this employee
GetEmployeeTimecards();
// Get recent weeks go into the Week combobox
InitializeComboBox();
// If we have weeks in our combo box then select the most recent monday and determine what week number that is
if (comboBoxWeek.Items.Count > 0)
{
comboBoxWeek.SelectedIndex = comboBoxWeek.Items.Count - 1;
_thisWeekNumber = comboBoxWeek.SelectedItem.ToString().Substring(19);
}
// if we have a timecard for the given week...
if (_timecards.Count > 0)
{
foreach (Timecard tc in _timecards)
{
if (tc.WeekNumber == _thisWeekNumber)
{
_timecardUnderGlass = tc;
// Fetch timecard detail from the DB into _thisTcDetail
GetTimecardDetails();
break;
}
}
}
dgvTimecardDetail.DataSource = _bindingSource1;
_bindingSource1.DataSource = _tcDetailsUnderGlass;
//Do not display these columns in the grid
dgvTimecardDetail.Columns["IsBlank"].Visible = false;
dgvTimecardDetail.Columns["TaskId"].Visible = false;
dgvTimecardDetail.Columns["TimecardId"].Visible = false;
dgvTimecardDetail.Columns["DetailId"].Visible = false;
_currentFormState = FormState.ViewingData;
AssertFormState();
// Get the employee's data onto the form
UpdateWeekHoursTotalOnTitleBar();
}
private static bool addLinesHelper(TimeClockContext db, Punch punch, Timecard tc, PayType pt, double weeklyWorked, double dailyWorked, DateTime splitStart, DateTime splitEnd, bool seventhDay)
{
// a simple base case, to stop spawing extra lines -- Not sure if this is needed
if (splitStart.Subtract(splitEnd).TotalMinutes == 0)
{
return(true);
}
// Determin the correct pay type for this line.
while (weeklyWorked > pt.getWeeklyMax(seventhDay))
{
pt = pt.NextPayType;
}
while (dailyWorked > pt.getDailyMax(seventhDay))
{
pt = pt.NextPayType;
}
// Calculate dailyLeft and weeklyLeft
double dailyLeft = (double)pt.getDailyMax(seventhDay) - dailyWorked;
double weeklyLeft = (double)pt.getWeeklyMax(seventhDay) - dailyWorked;
double splitLength = splitEnd.Subtract(splitStart).TotalMinutes;
// Check if we reach over the weekly -- if
if (weeklyWorked + splitLength > pt.getWeeklyMax(seventhDay))
{
addLinesHelper(db, punch, tc, pt, weeklyWorked, dailyWorked, splitStart, splitStart.AddMinutes(weeklyLeft), seventhDay);
addLinesHelper(db, punch, tc, pt.NextPayType, weeklyWorked + weeklyLeft, dailyWorked + weeklyLeft, splitStart.AddMinutes(weeklyLeft), splitEnd, seventhDay);
}
// Check if we reached over the daily limit
else if (dailyWorked + splitLength > pt.getDailyMax(seventhDay))
{
addLinesHelper(db, punch, tc, pt, weeklyWorked, dailyWorked, splitStart, splitStart.AddMinutes(dailyLeft), seventhDay);
addLinesHelper(db, punch, tc, pt.NextPayType, weeklyWorked + dailyLeft, dailyWorked + dailyLeft, splitStart.AddMinutes(dailyLeft), splitEnd, seventhDay);
}
// we can safely add the line to the DB
else
{
db.Lines.Add(new Line()
{
TimecardID = tc.TimecardID,
PunchID = punch.PunchID,
SplitStart = splitStart,
SplitEnd = splitEnd,
PayTypeID = pt.PayTypeID
});
db.SaveChanges();
}
return(true);
}
/// <summary>
/// Deletes the current timecard, then retrieves the most recent timecard before it
/// </summary>
public void DeleteTimecard()
{
var id = _timecard.ID;
var date = _timecard.Date;
var repo = _factory.Resolve <IRepository>();
repo.DeleteTimecard(id);
_timecard = repo.GetNearestTimecard(date, false)
?? throw new TimecardNotFoundException();
}
/// <summary>
/// Gets the timecard just after the current timecard's date
/// </summary>
/// <returns>The next timecard</returns>
public Timecard GetNextTimecard()
{
var repo = _factory.Resolve <IRepository>();
_timecard = repo.GetNearestTimecard(_timecard.Date, true);
if (_timecard == null)
{
RetrieveTimecardFromEdge(true);
}
return(_timecard);
}
public IActionResult UpdateLine(string timecardId, string lineId, [FromBody] TimecardLine timecardLine)
{
Timecard timecard = Database.Find(timecardId);
if (timecard == null)
{
return(NotFound());
}
return(Ok());
}
/* This functions determine the weekly minuts worked, as well as the time that the current payday started.
*
* This information is then used to call addLinesDaily(...);
*/
private static bool addLinesTimecard(TimeClockContext db, Punch punch, Timecard tc, DateTime splitStart, DateTime splitEnd)
{
// Calculate weeklyWorked, and dailyWorked
var lines = db.Lines.Where(l => l.TimecardID == tc.TimecardID);
double weeklyMinuts = punch.employee.minutesWorkedWeek(db, splitStart);
TimeSpan dayBeginTime = punch.employee.department.PayPeriodSeed.TimeOfDay;
DateTime currentDayStart = DateTime.Now.Date.Add(dayBeginTime);
return(addLinesDaily(db, punch, tc, splitStart, splitEnd, weeklyMinuts, currentDayStart));
}
private void newTimecardAddButton_Click(object sender, RoutedEventArgs e)
{
DateTime date = (DateTime)datePicker.Value;
String timecardID = System.Guid.NewGuid().ToString();
// Create a new timecard based on the text box.
Timecard newTimecard = new Timecard {
TimecardName = newTimecardTextBox.Text, IsComplete = false, TimecardID = timecardID, StartDate = HelperClass.GetFirstDayOfWeek(date)
};
App.AppViewModel.AddNewTimecard(newTimecard);
}
/*EventHandler
*
************************/
private void changeTimecardButton_Click(object sender, RoutedEventArgs e)
{
var button = sender as Button;
if (button != null)
{
// Get a handle for the to-do item bound to the button.
Timecard timecard = button.DataContext as Timecard;
// hier muss noch die ID mitgegeben werden, dass die Timecard korrekt geladen werden kann
NavigationService.Navigate(new Uri("/View/TimecardPage.xaml?timecardIDParam=" + timecard.TimecardID, UriKind.Relative));
}
}
private void addTimecardOnTop(Timecard tc)
{
ObservableCollection <Timecard> tmpCollection = new ObservableCollection <Timecard>();
tmpCollection.Add(tc);
foreach (Timecard singleTimecard in currentTimecardCollection)
{
tmpCollection.Add(singleTimecard);
}
CurrentTimecardCollection = tmpCollection;
}
public IActionResult GetOne(string id)
{
Timecard timecard = Database.Find(id);
if (timecard != null)
{
return(Ok(timecard));
}
else
{
return(NotFound());
}
}
/* This functions determine the weekly minuts worked, as well as the time that the current payday started.
*
* This information is then used to call addLinesDaily(...);
*/
private static bool addLinesTimecard(TimeClockContext db, Punch punch, Timecard tc, DateTime splitStart, DateTime splitEnd)
{
// Calculate weeklyWorked, and dailyWorked
var lines = db.Lines.Where(l => l.TimecardID == tc.TimecardID);
double weeklyMinuts = punch.employee.minutesWorkedWeek(db, splitStart);
TimeSpan dayBeginTime = punch.employee.department.PayPeriodSeed.TimeOfDay;
DateTime currentDayStart = DateTime.Now.Date.Add(dayBeginTime);
return addLinesDaily(db, punch, tc, splitStart, splitEnd, weeklyMinuts, currentDayStart);
}
private static bool addLinesHelper(TimeClockContext db, Punch punch, Timecard tc, PayType pt, double weeklyWorked, double dailyWorked, DateTime splitStart, DateTime splitEnd, bool seventhDay)
{
// a simple base case, to stop spawing extra lines -- Not sure if this is needed
if (splitStart.Subtract(splitEnd).TotalMinutes == 0)
return true;
// Determin the correct pay type for this line.
while (weeklyWorked > pt.getWeeklyMax(seventhDay))
pt = pt.NextPayType;
while (dailyWorked > pt.getDailyMax(seventhDay))
pt = pt.NextPayType;
// Calculate dailyLeft and weeklyLeft
double dailyLeft = (double) pt.getDailyMax(seventhDay) - dailyWorked;
double weeklyLeft = (double) pt.getWeeklyMax(seventhDay) - dailyWorked;
double splitLength = splitEnd.Subtract(splitStart).TotalMinutes;
// Check if we reach over the weekly -- if
if (weeklyWorked + splitLength > pt.getWeeklyMax(seventhDay))
{
addLinesHelper(db, punch, tc, pt, weeklyWorked, dailyWorked, splitStart, splitStart.AddMinutes(weeklyLeft), seventhDay);
addLinesHelper(db, punch, tc, pt.NextPayType, weeklyWorked + weeklyLeft, dailyWorked + weeklyLeft, splitStart.AddMinutes(weeklyLeft), splitEnd, seventhDay);
}
// Check if we reached over the daily limit
else if (dailyWorked + splitLength > pt.getDailyMax(seventhDay))
{
addLinesHelper(db, punch, tc, pt, weeklyWorked, dailyWorked, splitStart, splitStart.AddMinutes(dailyLeft), seventhDay);
addLinesHelper(db, punch, tc, pt.NextPayType, weeklyWorked + dailyLeft, dailyWorked + dailyLeft, splitStart.AddMinutes(dailyLeft), splitEnd, seventhDay);
}
// we can safely add the line to the DB
else
{
db.Lines.Add(new Line()
{
TimecardID = tc.TimecardID,
PunchID = punch.PunchID,
SplitStart = splitStart,
SplitEnd = splitEnd,
PayTypeID = pt.PayTypeID
});
db.SaveChanges();
}
return true;
}
/*
* this split up the punch to the different days that it happen, this is done recursively, and call allLinesHelper on the corresponding days
*
*/
private static bool addLinesDaily(TimeClockContext db, Punch punch, Timecard tc, DateTime splitStart, DateTime splitEnd, double weeklyWorked, DateTime dayStartTime)
{
// Split on days
if(splitStart.Subtract(dayStartTime).TotalMinutes < 0) // the punch started on the previous day, split and call recursively
{
addLinesDaily(db, punch, tc, splitStart, dayStartTime, weeklyWorked, dayStartTime.AddDays(-1));
splitStart = dayStartTime; // To continue adding the rest of the punch
}
if(splitEnd.Subtract(dayStartTime.AddDays(1)).TotalMinutes < 0) // the punch ended today, we can safely add it
{
double dailyworked = punch.employee.minutsWorkedDate(db, dayStartTime);
bool seventhDay = punch.employee.workedSixPreviousDays(db);
addLinesHelper(db, punch, tc, punch.employee.department.DefaultPayType, weeklyWorked, dailyworked, splitStart, splitEnd, seventhDay);
}
else // The punch ends on the next day
{
double dailyworked = punch.employee.minutsWorkedDate(db, dayStartTime);
bool seventhDay = punch.employee.workedSixPreviousDays(db);
addLinesHelper(db, punch, tc, punch.employee.department.DefaultPayType, weeklyWorked, dailyworked, splitStart, dayStartTime.AddDays(1), seventhDay);
addLinesDaily(db, punch, tc, dayStartTime.AddDays(1), splitEnd, weeklyWorked, dayStartTime.AddDays(1));
}
return true;
}
