/// <summary>
/// This sets a booking to cancelled. You do not want a hard delete as
/// it could be used in analytics as to what customers mess you around
/// </summary>
/// <param name="appGuid"></param>
/// <returns></returns>
public async Task <ReturnDto <bool> > DeleteAppointment(Guid appGuid)
{
var rtn = new ReturnDto <bool>();
if (appGuid == null || appGuid == Guid.Empty)
{
rtn.ErrorCode = ErrorCodes.APPOINTMENT_GUID_NOT_PROVIDED;
rtn.ReturnObject = false;
return(rtn);
}
try
{
rtn.ReturnObject = await _appointmentRepo.DeleteAppointment(appGuid);
}
catch (Exception e) {
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = false;
_logger.LogError($"An error occured in - {typeof(AppointmentService)} - Delete Appointment - Message: {e.Message} - A: {appGuid}");
}
return(rtn);
}
/// <summary>
/// Send upload request
/// </summary>
/// <param name="">TODO</param>
/// <returns>true if request was successful and false if unsuccessful</returns>
public static string Upload(string fullName, string password, double expiration, int maxDownloads)
{
FileDto file = new FileDto(fullName, password, false, expiration, maxDownloads);
ReturnDto returnDto = SendRequest(file);
return(returnDto.Message);
}
public static void HandleIt(TcpClient client)
{
Console.WriteLine("Connected to a client");
ReturnDto returnDto = new ReturnDto(false, "Something went really wrong");
using (NetworkStream stream = client.GetStream())
{
XmlSerializer reader = new XmlSerializer(typeof(FileDto));
FileDto file = (FileDto)reader.Deserialize(stream);
using (SmartShareContext db = new SmartShareContext())
{
Dao dao = new Dao(db, file);
if (file.Data != null)
{
returnDto = dao.Upload();
}
else if (file.View)
{
returnDto = dao.View();
}
else
{
returnDto = dao.Download();
}
}
XmlSerializer serializer = new XmlSerializer(typeof(ReturnDto));
serializer.Serialize(stream, returnDto);
client.Client.Shutdown(SocketShutdown.Both);
}
}
public static string View(string filename, string password)
{
FileDto file = new FileDto(filename, password, true);
ReturnDto returnDto = SendRequest(file);
return(returnDto.Message);
}
public async Task <ReturnDto <List <Appointment> > > GetAppointmentsByDate(DateTime dt, Guid userGuid, bool dayOnly = false)
{
var rtn = new ReturnDto <List <Appointment> >();
if (userGuid == null || userGuid == Guid.Empty)
{
rtn.ErrorCode = ErrorCodes.USER_GUID_NOT_PROVIDED;
rtn.ReturnObject = null;
return(rtn);
}
try
{
rtn.ReturnObject = await _appointmentRepo.GetAppointments(userGuid, dt, dayOnly);
}
catch (Exception e)
{
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = null;
_logger.LogError($"An error occured in - {typeof(AppointmentService)} - Get Appointments By Date- Message: {e.Message} - DT: {dt}, U: {userGuid}, DO: {dayOnly}");
}
return(rtn);
}
public ReturnDto View()
{
ReturnDto returnDto;
var query = from f in Db.Files
where f.Filename == this.File.Filename
select f;
var dbFile = query.SingleOrDefault();
Console.WriteLine(dbFile);
Console.WriteLine(dbFile.Password.Equals(File.Password));
if (dbFile != null && dbFile.Password.Equals(File.Password))
{
DateTime now = DateTime.Now;
var timeLeft = dbFile.Expiration.Subtract(now).TotalMinutes;
if (timeLeft > 0)
{
var downloadsLeft = dbFile.MaxDownloads == -1 ? "unlimited" : (dbFile.MaxDownloads - dbFile.Downloads).ToString();
return(returnDto = new ReturnDto(true, $"{File.Filename} can be downloaded {downloadsLeft} times in the next {timeLeft} minutes."));
}
else
{
Db.Files.Remove(dbFile);
Db.SaveChanges();
}
}
return(returnDto = new ReturnDto(false, "File could not be viewed"));
}
public async Task <ReturnDto <User> > UpdateUser(User user)
{
var rtn = new ReturnDto <User>();
if (user == null)
{
rtn.ErrorCode = ErrorCodes.OBJECT_NOT_PROVIDED;
rtn.ReturnObject = null;
return(rtn);
}
try
{
rtn.ReturnObject = await _userRepo.UpdateUser(user);
}
catch (Exception e)
{
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = null;
_logger.LogError($"An error occured in - {nameof(UserService)} - Update User - Message: {e.Message} - U: {user.UserGuid}");
}
return(rtn);
}
/// <summary>
/// 更新借出归还信息
/// </summary>
/// <param name="returnDto"></param>
public void AssetsReturn(ReturnDto returnDto)
{
var borrow = _borrowRep.Find(returnDto.BorrowId);
if (null == borrow)
{
throw new Exception("未找到对应的借用记录");
}
if (borrow.HasReturn > 0)
{
throw new Exception("已经归还");
}
borrow.ReturnPerson = returnDto.ReturnPerson;
borrow.ReturnDate = returnDto.ReturnDate;
borrow.ReturnMome = returnDto.ReturnMome;
borrow.HasReturn = 1;
_borrowRep.Update(borrow);
foreach (var statu in returnDto.AssetsStatus)
{
var detail =
_borrowDetailRep.FirstOrDefault(d => d.BorrowFormNo == borrow.EntityId && d.AssetsNo == statu.Key);
if (null != detail)
{
detail.ReturnStatus = statu.Value;
_borrowDetailRep.Update(detail);
}
}
//清空使用人
_assetsMainRep.UpdateUsePeople("", returnDto.AssetsStatus.Select(x => x.Key).ToList());
}
public async Task <ReturnDto <bool> > AddCustomerRate(Rate customerRate)
{
var rtn = new ReturnDto <bool>();
if (customerRate == null)
{
rtn.ErrorCode = ErrorCodes.OBJECT_NOT_PROVIDED;
rtn.ReturnObject = false;
return(rtn);
}
try
{
rtn.ReturnObject = await _customerRatesRepo.AddCustomerRate(customerRate);
}
catch (Exception e) {
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = false;
_logger.LogError($"An error occured in - {typeof(CustomerRatesService)} - Add Customer Rate - Message: {e.Message} - R: {customerRate.RateGuid}, C: {customerRate.CustomerGuid}");
}
return(rtn);
}
public ReturnDto Download()
{
ReturnDto returnDto;
var query = from f in Db.Files
where f.Filename == this.File.Filename
select f;
var dbFile = query.SingleOrDefault();
DateTime now = DateTime.Now;
if (dbFile != null)
{
if (dbFile.Password.Equals(File.Password))
{
if (now.CompareTo(dbFile.Expiration) > 0)
{
Db.Files.Remove(dbFile);
Db.SaveChanges();
}
else
{
returnDto = new ReturnDto(true, "File downloaded successfully", dbFile.Filename, dbFile.Data);
dbFile.Downloads += 1;
if (dbFile.Downloads == dbFile.MaxDownloads)
{
Db.Files.Remove(dbFile);
}
Db.SaveChanges();
return(returnDto);
}
}
}
return(returnDto = new ReturnDto(false, "File could not be downloaded."));
}
public async Task <ReturnDto <List <Rate> > > GetCustomerRates(Guid customerGuid)
{
var rtn = new ReturnDto <List <Rate> >();
if (customerGuid == null || customerGuid == Guid.Empty)
{
rtn.ErrorCode = ErrorCodes.CUSTOMER_GUID_NOT_PROVIDED;
rtn.ReturnObject = null;
return(rtn);
}
try
{
rtn.ReturnObject = await _customerRatesRepo.GetCustomerRate(customerGuid);
}
catch (Exception e)
{
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = null;
_logger.LogError($"An error occured in - {typeof(CustomerRatesService)} - Get Customer Rates - Message: {e.Message} - C: {customerGuid}");
}
return(rtn);
}
public async Task <ReturnDto <bool> > AddAppointment(Appointment app)
{
var rtn = new ReturnDto <bool>();
if (app == null)
{
rtn.ErrorCode = ErrorCodes.OBJECT_NOT_PROVIDED;
rtn.ReturnObject = false;
return(rtn);
}
try
{
rtn.ReturnObject = await _appointmentRepo.AddAppointment(app);
}
catch (Exception e)
{
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = false;
_logger.LogError($"An error occured in - {typeof(AppointmentService)} - Add Appointment - Message: {e.Message} - A: {app.AppointmentGuid}, U: {app.UserGuid}, C: {app.CustomerGuid}");
}
return(rtn);
}
public async Task <ReturnDto <List <Customer> > > ListCustomers(Guid userGuid, bool onlyActive = true)
{
var rtn = new ReturnDto <List <Customer> >();
//TODO: Should deal with limiting in the repo and underlining call to db to minimise data transfer
if (userGuid == null || userGuid == Guid.Empty)
{
rtn.ErrorCode = ErrorCodes.USER_GUID_NOT_PROVIDED;
rtn.ReturnObject = null;
return(rtn);
}
List <Customer> rtnCustomers = null;
try
{
rtnCustomers = await _custRepo.ListCustomers(userGuid);
}
catch (Exception e) {
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = null;
_logger.LogError($"An error occured in - {typeof(CustomerService)} - List Customers - Message: {e.Message} - U: {userGuid} - Active: {onlyActive}");
}
rtn.ReturnObject = onlyActive ? rtnCustomers?.Where(x => x.Archived == false).ToList() ?? null : rtnCustomers;
return(rtn);
}
public async Task <ReturnDto <User> > GetUser(Guid userGuid)
{
var rtn = new ReturnDto <User>();
if (userGuid == null || userGuid == Guid.Empty)
{
rtn.ErrorCode = ErrorCodes.USER_GUID_NOT_PROVIDED;
rtn.ReturnObject = null;
return(rtn);
}
try {
rtn.ReturnObject = await _userRepo.GetUser(userGuid);
}
catch (Exception e)
{
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = null;
_logger.LogError($"An error occured in - {nameof(UserService)} - Get User - Message: {e.Message} - U: {userGuid}");
}
return(rtn);
}
public async Task <ReturnDto <bool> > ChangePassword(Guid userGuid, string password)
{
var rtn = new ReturnDto <bool>();
if (string.IsNullOrEmpty(password) || (userGuid == null || userGuid == Guid.Empty))
{
rtn.ErrorCode = ErrorCodes.OBJECT_NOT_PROVIDED;
rtn.ReturnObject = false;
return(rtn);
}
try
{
rtn.ReturnObject = await _userRepo.ChangePassword(userGuid, password);
}
catch (Exception e)
{
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = false;
_logger.LogError($"An error occured in - {nameof(UserService)} - Update User - Message: {e.Message} - U: {userGuid}");
}
return(rtn);
}
public async Task <ReturnDto <bool> > RemoveUser(Guid userGuid, bool cleanseUser = false)
{
var rtn = new ReturnDto <bool>();
if (userGuid == null || userGuid == Guid.Empty)
{
rtn.ErrorCode = ErrorCodes.USER_GUID_NOT_PROVIDED;
rtn.ReturnObject = false;
return(rtn);
}
try {
rtn.ReturnObject = await _userRepo.DeleteUser(userGuid);
}
catch (Exception e)
{
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = false;
_logger.LogError($"An error occured in - {nameof(UserService)} - Remove User - Message: {e.Message} - U: {userGuid}, CU: {cleanseUser}");
}
//someones sub may laps so we do not want to wipe them from the system fully all the time. This option is used when fully deleting when complying with a 'Rrequest To Delete'
if (cleanseUser)
{
//cleanse the user data to annonymise it to comply with GDPR
}
return(rtn);
}
public async Task <object> Login(LoginDto loginDto)
{
if (!string.IsNullOrWhiteSpace(loginDto.Email) && !string.IsNullOrWhiteSpace(loginDto.Password))
{
var checkUser = await _context.Users.FirstOrDefaultAsync(c => c.Deleted == true);
if (checkUser != null)
{
return(Result.Failure(new List <string> {
"User deleted!!!"
}), checkUser.Id);
}
var user = await _context.Users.FirstOrDefaultAsync(c => c.Email == loginDto.Email) ??
(await _userManager.FindByEmailAsync(loginDto.Email) ?? await _userManager.FindByEmailAsync(loginDto.Email));
if (user == null)
{
throw new UnauthorizedAccessException("User not found! Please register");
}
if (user.ActiveStatus != "Y")
{
throw new UnauthorizedAccessException("User not active yet!!!");
}
var result = await _signInManager.CheckPasswordSignInAsync(user, loginDto.Password, false);
if (result.Succeeded)
{
ReturnDto appUser = new ReturnDto
{
Id = user.Id,
Email = user.Email,
PhoneNumber = user.PhoneNumber,
CountryCode = user.CountryCode,
ActiveStatus = user.ActiveStatus,
UserTypeId = user.UserTypeId,
PhoneNumberConfirmed = user.PhoneNumberConfirmed,
TwoFactorEnabled = user.TwoFactorEnabled
};
return(new
{
token = GenerateJwtToken(user).Result,
user = appUser
});
}
throw new UnauthorizedAccessException("Invalid Email or Password!!!");
}
throw new NotFoundException(nameof(User), loginDto.Email);
}
public ReturnDto UpdatePMBooking(UpdatePMTimeDto _Updaterequest)
{
ReturnDto returndata = new ReturnDto();
var TimeSheetRecord = _context.PMTimeSheets.Where(c => c.id == _Updaterequest.Id).FirstOrDefault();
try
{
if (TimeSheetRecord != null)
{
//if (_Updaterequest.Day != null && TimeSheetRecord.Day != _Updaterequest.Day)
//{
// TimeSheetRecord.Day =Convert.ToDateTime( _Updaterequest.Day);
//}
if (_Updaterequest.StartTime != null && TimeSheetRecord.StartTime != _Updaterequest.StartTime)
{
TimeSheetRecord.StartTime = Convert.ToDateTime(_Updaterequest.StartTime);
}
if (_Updaterequest.EndTime != null && TimeSheetRecord.EndTime != _Updaterequest.EndTime)
{
TimeSheetRecord.EndTime = Convert.ToDateTime(_Updaterequest.EndTime);
}
if (_Updaterequest.BreakHours > 0 && TimeSheetRecord.BreakHours != _Updaterequest.BreakHours)
{
TimeSheetRecord.BreakHours = _Updaterequest.BreakHours;
}
if (_Updaterequest.BreakTime != null && TimeSheetRecord.BreakTime != _Updaterequest.BreakTime)
{
TimeSheetRecord.BreakTime = _Updaterequest.BreakTime;
}
if (_Updaterequest.StatusID > 0 && TimeSheetRecord.StatusID != _Updaterequest.StatusID)
{
TimeSheetRecord.StatusID = _Updaterequest.StatusID;
}
if (_Updaterequest.TimeSheetComments != null && TimeSheetRecord.TimesheetComments != _Updaterequest.TimeSheetComments)
{
TimeSheetRecord.TimesheetComments = _Updaterequest.TimeSheetComments;
}
_context.SaveChanges();
returndata.Message = "TimeSheet Record Updated Sucessfully";
returndata.IsSuccess = true;
// LogHistory(_Updaterequest.Id, _Updaterequest.FullName, false);
}
else
{
returndata.Message = "TimeSheet Record Not Found To Updated !";
returndata.IsSuccess = false;
}
}
catch (Exception ex)
{
returndata.Message = ex.Message;
returndata.IsSuccess = false;
}
return(returndata);
}
/// <summary>
/// Send download request
/// </summary>
/// <param name="">TODO</param>
/// <returns>true if request was successful and false if unsuccessful</returns>
public static string Download(string filename, string password)
{
FileDto file = new FileDto(filename, password, false);
ReturnDto returnDto = SendRequest(file);
if (returnDto.Data != null)
{
File.WriteAllBytes($"..\\Downloads\\{returnDto.Filename}", returnDto.Data);
}
return(returnDto.Message);
}
public ReturnDto ProjectionEntry(ProjectionEntryDto EntryModel)
{
var ReturnModel = new ReturnDto();
if (EntryModel == null)
{
return(FailedProjectionEntry(ReturnModel));
}
var pmId = _context.OpportunityNumbers.Where(o => o.OpportunityNumber == EntryModel.OpportunityID).FirstOrDefault();
if (pmId == null)
{
return(FailedProjectionEntry(ReturnModel));
}
if (EntryModel.ActivityId <= 0)
{
EntryModel.ActivityId = 0;
}
EntryModel.OpportunityID = Convert.ToInt32(pmId.Id);
try
{
var ProjectItemEntry = new Projection()
{
ProjectID = Convert.ToInt32(pmId.ProjectID),
ProjectManagerID = Convert.ToInt32(pmId.ProjectManagerID),
ActivityId = EntryModel.ActivityId,
WarehouseId = EntryModel.WarehouseId,
Created = DateTime.Now,
OpportunityID = EntryModel.OpportunityID,
ServiceActivityId = EntryModel.ServiceActivityId,
Quantity = EntryModel.ProjectionQuantity,
DateInvoiced = EntryModel.DateInvoiced,
DateAllocated = EntryModel.DateAllocated,
Comments = EntryModel.Comments
};
_context.Projection.Add(ProjectItemEntry);
Save();
ReturnModel.Message = "Projection Entry Registered Sucessfully!";
ReturnModel.IsSuccess = true;
}
catch (Exception ex)
{
ReturnModel.Message = ex.Message;
ReturnModel.IsSuccess = false;
}
return(ReturnModel);
}
public async Task <ReturnDto <List <User> > > GetUsers()
{
var rtn = new ReturnDto <List <User> >();
try {
rtn.ReturnObject = await _userRepo.GetUsers();
}
catch (Exception e)
{
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = null;
_logger.LogError($"An error occured in - {nameof(UserService)} - Get Users - Message: {e.Message}");
}
return(rtn);
}
private async Task <ReturnDto> ResultFactory(VerifyEnum authority, IssuerVerifyResult verifyResult)
{
ReturnDto ret = new ReturnDto();
switch (authority)
{
case VerifyEnum.account:
case VerifyEnum.refreshToken:
ret = AccountResult(verifyResult);
break;
case VerifyEnum.otp:
case VerifyEnum.login:
ret = await OtpAndUserResult(verifyResult);
break;
}
return(ret);
}
//public void AddProjectionDetails(int ProjectionID, int Quantity, DateTime updateDate)
//{
// var IsdetailsExists = _context.ProjectionUpdateDetails
// .Where(p => p.FK_ProjectionID == ProjectionID && p.Quantity == Quantity)
// .Where(d => DateTime.Compare(d.Updated, updateDate) <= 0).FirstOrDefault();
// if (IsdetailsExists ==null)
// {
// var _AddprojectionDetails = new ProjectionUpdateDetails()
// {
// FK_ProjectionID = ProjectionID,
// Quantity=Quantity,
// Updated=updateDate
// };
// _context.ProjectionUpdateDetails.Add(_AddprojectionDetails);
// Save();
// }
//}
public ReturnDto ProjectionUpdate(ProjectionUpdateDto EntryModel)
{
var ReturnData = new ReturnDto();
try
{
var UpdateProjection = _context.Projection.Where(x => x.Id == EntryModel.ProjectionID).FirstOrDefault();
if (UpdateProjection != null)
{
UpdateProjection.DateModified = DateTime.Now;
if (UpdateProjection.Quantity != EntryModel.ProjectionQuantity)
{
UpdateProjection.Quantity = EntryModel.ProjectionQuantity;
}
if (UpdateProjection.DateAllocated != EntryModel.DateAllocated)
{
UpdateProjection.DateAllocated = EntryModel.DateAllocated;
}
if (UpdateProjection.DateInvoiced != EntryModel.DateInvoiced)
{
UpdateProjection.DateInvoiced = EntryModel.DateInvoiced;
}
if (UpdateProjection.Comments != EntryModel.Comments)
{
UpdateProjection.Comments = EntryModel.Comments;
}
if (UpdateProjection.WarehouseId != EntryModel.WarehouseID)
{
UpdateProjection.WarehouseId = EntryModel.WarehouseID;
}
Save();
ReturnData.IsSuccess = true;
ReturnData.Message = "Record Updated Sucessfuly";
}
}
catch (Exception ex)
{
ReturnData.IsSuccess = false;
ReturnData.Message = ex.Message;
}
return(ReturnData);
}
public static string UpdateOrderAddress(UpdateOrderAddressDto theModel)
{
string response = string.Empty;
var _ReturnDto = new ReturnDto();
string uri = System.Configuration.ConfigurationManager.AppSettings["rooturi"] + System.Configuration.ConfigurationManager.AppSettings["UpdateOrderAddress"];
string token = System.Web.HttpContext.Current.Session["BearerToken"].ToString();
try
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var resp = client.PostAsJsonAsync(uri, theModel);
resp.Wait(TimeSpan.FromSeconds(10));
if (resp.IsCompleted)
{
if (resp.Result.StatusCode == HttpStatusCode.Unauthorized)
{
Console.WriteLine("Authorization failed. Token expired or invalid.");
}
else
{
response = resp.Result.Content.ReadAsStringAsync().Result;
_ReturnDto = JsonConvert.DeserializeObject <ReturnDto>(response);
response = _ReturnDto.ErrorMessage;
if (string.IsNullOrEmpty(response))
{
response = _ReturnDto.OrderStatus;
}
}
}
}
}
catch (Exception ex)
{
response = ex.Message.ToString();
}
return(response);
}
private static ReturnDto ExceptionReturn(Exception exc)
{
ReturnDto ret;
var key = exc.Data.Keys.Cast <Gp_Error>().FirstOrDefault();
List <ErrorDto> errorData = new List <ErrorDto>();
switch (key)
{
case Gp_Error.IdentityResultFaild:
var statusMessage = exc.Data[key] as List <IdentityError>;
foreach (var item in statusMessage)
{
errorData.Add(new ErrorDto()
{
Description = item.Description,
Key = item.Code
});
}
break;
case Gp_Error.Unknown:
default:
errorData.Add(new ErrorDto()
{
Description = exc.Message,
Key = nameof(ErrorKey.Unknown)
});
break;
}
@ret = new ReturnDto()
{
Data = null,
ErrorData = errorData,
Status = false
};
return(ret);
}
public async Task <ReturnDto <List <Appointment> > > GetAllAppointments(Guid userGuid)
{
var rtn = new ReturnDto <List <Appointment> >();
if (userGuid == null || userGuid == Guid.Empty)
{
rtn.ErrorCode = ErrorCodes.USER_GUID_NOT_PROVIDED;
rtn.ReturnObject = null;
return(rtn);
}
try
{
rtn.ReturnObject = await _appointmentRepo.GetAppointments(userGuid : userGuid);
} catch (Exception e) {
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = null;
_logger.LogError($"An error occured in - {typeof(AppointmentService)} - Get All Appointments - Message: {e.Message} - A: {userGuid}");
}
return(rtn);
}
public async Task <IActionResult> GetAsync(int id)
{
if (id == 0)
{
return(BadRequest());
}
var entity = await _dbContext.Photos
.FirstOrDefaultAsync(p => p.Id.Equals(id))
.ConfigureAwait(false);
if (entity is null)
{
return(NotFound());
}
var returnDto = new ReturnDto
{
Id = entity.Id,
Url = entity.Url
};
return(Ok(returnDto));
}
public async Task <ReturnDto <Customer> > UpdateCustomer(Customer cust)
{
var rtn = new ReturnDto <Customer>();
if (cust == null)
{
rtn.ErrorCode = ErrorCodes.OBJECT_NOT_PROVIDED;
rtn.ReturnObject = null;
return(rtn);
}
try
{
rtn.ReturnObject = await _custRepo.UpdateCustomer(cust);
} catch (Exception e) {
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = null;
_logger.LogError($"An error occured in - {typeof(CustomerService)} - Update Customer - Message: {e.Message} - C: {cust.CustomerGuid}, U: {cust.UserGuid}");
}
return(rtn);
}
public async Task <ReturnDto <Customer> > GetCustomer(Guid userGuid, Guid customerGuid)
{
var rtn = new ReturnDto <Customer>();
if (userGuid == null || userGuid == Guid.Empty || customerGuid == null || customerGuid == Guid.Empty)
{
rtn.ErrorCode = ErrorCodes.REFERENCE_GUIDS_NOT_PROVIDED;
rtn.ReturnObject = null;
return(rtn);
}
try
{
rtn.ReturnObject = await _custRepo.GetCustomer(userGuid, customerGuid);
} catch (Exception e) {
rtn.ErrorCode = ErrorCodes.OTHER;
rtn.ReturnObject = null;
_logger.LogError($"An error occured in - {typeof(CustomerService)} - Get Customer - Message: {e.Message} - U: {userGuid} - C: {customerGuid}");
}
return(rtn);
}
public ReturnDto RegisterPMBooking(PMTimesheetRegisterDto _PmBookingRequest)
{
ReturnDto returndata = new ReturnDto();
var _Resource = _context.Candidate.Where(c => c.ID == _PmBookingRequest.ResourceID).FirstOrDefault();
if (_Resource == null)
{
returndata.Message = "Resource Not Found To Book";
returndata.IsSuccess = false;
return(returndata);
}
var IsPmBooked = _context.PMTimeSheets.Where(c => c.ResourceID == _PmBookingRequest.ResourceID &&
(c.StartTime >= _PmBookingRequest.StartTime && c.EndTime <= _PmBookingRequest.EndTime) &&
(c.Day.Day >= _PmBookingRequest.Day.Day && c.Day.Day <= _PmBookingRequest.Day.Day) &&
c.WarehouseID == _Resource.WarehouseID).FirstOrDefault();
if (IsPmBooked != null)
{
returndata.Message = "Resource Already Booked On Activity";
returndata.IsSuccess = false;
return(returndata);
}
int serviceactivityid = 0;
if (_PmBookingRequest.OpportunityID > 0)
{
var _serviceactivityid = _context.ServiceRevenue.Where(r => r.ServiceActivityID == _PmBookingRequest.ServiceActivityID && r.OpportunityNumberID == _PmBookingRequest.OpportunityID).FirstOrDefault();
if (_serviceactivityid != null)
{
serviceactivityid = Convert.ToInt32(_serviceactivityid.ServiceActivityID);
}
else
{
serviceactivityid = _PmBookingRequest.ServiceActivityID;
}
}
try
{
var NewActivity = new PMTimeSheets
{
ResourceID = _PmBookingRequest.ResourceID,
ServiceActivityID = serviceactivityid,
StartTime = _PmBookingRequest.StartTime,
EndTime = _PmBookingRequest.EndTime,
ProjectID = _PmBookingRequest.ProjectID,
Day = _PmBookingRequest.Day,
WarehouseID = _Resource.WarehouseID,
TimesheetComments = _PmBookingRequest.TimeSheetComments,
OpportunityID = _PmBookingRequest.OpportunityID,
AdditionalActivities = _PmBookingRequest.AdditionalActivities,
StatusID = 4,
Colour = _PmBookingRequest.Colour
};
_context.PMTimeSheets.Add(NewActivity);
_context.SaveChanges();
returndata.Message = "TimeSheet Registered Sucessfully";
returndata.IsSuccess = true;
// LogHistory(NewActivity.Id, candidatedata.FullName, true);
}
catch (Exception ex)
{
returndata.Message = ex.Message; //implement Logs
returndata.IsSuccess = false;
}
return(returndata);
}
