public ResponseModel GetEmployeesByCompanyId(string companyId)
{
ResponseModel response = new ResponseModel();
try
{
if (GuidUtil.IsGuidValid(companyId))
{
List <EmployeeFavInfoModel> employeeModels = new List <EmployeeFavInfoModel>();
var employees = _employeeRepository.GetEmployeesByCompanyId(Guid.Parse(companyId));
employees.ForEach(employee => {
var employeeModel = EmployeeToEmployeeFavModel(employee);
if (employeeModel != null)
{
employeeModels.Add(employeeModel);
}
});
response.Message = "Funcinários encontrados!";
response.Result = employeeModels;
response.Success = true;
}
else
{
response.Message = "Guid inválido";
}
}
catch (Exception e)
{
response.Message = $"Não foi possível buscar os funcionários. {e.InnerException.Message}";
}
return(response);
}
public EditCompanyModelValidator()
{
RuleFor(x => x.UserId)
.NotNull()
.NotEmpty()
.Must(id => GuidUtil.IsGuidValid(id))
.WithMessage("UserId inválido");
RuleFor(x => x.LimitCancelHours)
.NotNull()
.WithMessage("Campo LimitCancelhours não pode ser nulo");
}
public EditUserModelValidator()
{
RuleFor(x => x.UsuarioId)
.NotNull()
.NotEmpty()
.Must(id => GuidUtil.IsGuidValid(id))
.WithMessage("Guid inválido");
RuleFor(x => x.Name)
.NotNull()
.WithMessage("O campo Nome não pode ser nulo");
}
public ResponseModel GetEmployeeMonthSchedule(string userId, int ano, int mes)
{
ResponseModel resp = new ResponseModel();
try
{
if (GuidUtil.IsGuidValid(userId))
{
var employee = _employeeRepository.GetEmployeeByUserId(Guid.Parse(userId));
if (employee != null)
{
List <GetEmployeeWorkScheduleModel> scheduleModel = new List <GetEmployeeWorkScheduleModel>();
var workHours = _employeeWorkHoursRepository.GetByMesAno(mes, ano, employee.EmployeeId);
if (workHours != null && workHours.Count > 0)
{
workHours.ForEach(workHour => {
GetEmployeeWorkScheduleModel model = new GetEmployeeWorkScheduleModel
{
Dia = workHour.StartHour.Day,
StartHour = workHour.StartHour.ToString(),
EndHour = workHour.EndHour.ToString(),
StartInterval = workHour.StartInterval.ToString(),
EndInterval = workHour.EndInterval.ToString()
};
scheduleModel.Add(model);
});
}
resp.Success = true;
resp.Message = "Horários do mês";
resp.Result = scheduleModel;
}
else
{
resp.Message = "Funcionário não encontrado";
}
}
else
{
resp.Message = "Id inválido";
}
}catch (Exception e)
{
resp.Message = $"Não foi possível recuperar os horários para este mês. \n{e.Message}";
}
return(resp);
}
public ResponseModel GetCompanyInfo(string companyId)
{
ResponseModel responseModel = new ResponseModel();
if (GuidUtil.IsGuidValid(companyId))
{
responseModel = GetCompanyComplete(Guid.Parse(companyId));
}
else
{
responseModel.Message = "Guid inválido";
}
return(responseModel);
}
public ResponseModel GetEmployeeInfo(string employeeId)
{
ResponseModel response = new ResponseModel();
if (GuidUtil.IsGuidValid(employeeId))
{
response = GetEmployeeInfoComplete(Guid.Parse(employeeId));
}
else
{
response.Message = "Guid inválido";
}
return(response);
}
public EditClientModelValidator()
{
RuleFor(x => x.UserId)
.NotNull()
.NotEmpty()
.Must(id => GuidUtil.IsGuidValid(id))
.WithMessage("UserId inválido");
RuleFor(x => x.RG)
.NotNull()
.NotEmpty()
.Must(rg => {
Regex rx = new Regex(@"(^\d{1,2}).?(\d{3}).?(\d{3})-?(\d{1}|X|x$)", RegexOptions.None);
return(rx.IsMatch(rg));
})
.WithMessage("RG com formato inválido");
}
public ResponseModel AddUserImage(AddUserImageModel model)
{
ResponseModel responseModel = new ResponseModel();
try
{
if (GuidUtil.IsGuidValid(model.UserId))
{
var user = _userRepository.GetById(Guid.Parse(model.UserId));
if (user != null)
{
string img = null;
if (model.Image != null)
{
ResponseModel resultImg = DownloadImage(model.Image, model.UserId).Result;
if (resultImg.Success)
{
img = resultImg.Result.ToString();
}
}
user.Image = img;
user.LastUpdatedAt = DateTimeUtil.UtcToBrasilia();
user.UpdatedBy = user.UserId;
_userRepository.Edit(user);
responseModel.Success = true;
responseModel.Result = img;
responseModel.Message = "Imagem atualizada com sucesso!";
}
else
{
responseModel.Message = "Usuário não encontrado";
}
}
else
{
responseModel.Message = "Guid inválido";
}
} catch (Exception e)
{
responseModel.Message = $"Não foi possível adicionar a imagem ao usuário. {e.Message} / {e.InnerException.Message}";
}
return(responseModel);
}
public AddEmployeeModelValidator()
{
RuleFor(x => x.CompanyId)
.NotNull()
.NotEmpty()
.WithMessage("O Campo CompanyId não pode ser nulo");
RuleFor(x => x.CompanyId)
.Must(companyId => {
return(GuidUtil.IsGuidValid(companyId));
})
.WithMessage("CompanyId com formato inválido");
RuleFor(x => x.IsManager)
.NotNull()
.WithMessage("O campo IsManager não pode ser nulo");
RuleFor(x => x.RG)
.NotNull()
.NotEmpty()
.WithMessage("O campo RG não pode ser nulo");
RuleFor(x => x.RG)
.NotNull()
.Must(rg => {
Regex rx = new Regex(@"(^\d{1,2}).?(\d{3}).?(\d{3})-?(\d{1}|X|x$)", RegexOptions.None);
return(rx.IsMatch(rg));
})
.WithMessage("CPF com formato inválido");
RuleFor(x => x.CPF)
.NotNull()
.NotEmpty()
.WithMessage("O campo CPF não pode ser nulo");
RuleFor(x => x.CPF)
.NotNull()
.Must(cpf => {
Regex rx = new Regex(@"[0-9]{3}\.?[0-9]{3}\.?[0-9]{3}\-?[0-9]{2}", RegexOptions.None);
return(rx.IsMatch(cpf));
})
.WithMessage("CPF com formato inválido");
}
public ResponseModel GetClientPerfilInfo(string userId)
{
ResponseModel response = new ResponseModel();
try
{
if (GuidUtil.IsGuidValid(userId))
{
Client cliente = _clientRepository.GetClientByUserId(Guid.Parse(userId));
if (cliente != null)
{
var clientModel = new GetClientPerfilInfoModel
{
Nome = cliente.User.Name,
Email = cliente.User.Email,
Imagem = cliente.User.Image,
CPF = cliente.CPF,
RG = cliente.RG,
DataCadastro = cliente.User.CreatedAt.ToString(),
Locations = _locationService.UserLocationsToBasicLocationModel(cliente.UserId),
PhoneNumbers = _phoneNumberService.UserPhoneNumbersToPhoneNumberModel(cliente.UserId)
};
response.Success = true;
response.Result = clientModel;
response.Message = "Informações do cliente";
}
else
{
response.Message = "Não foi possível encontrar o cliente";
}
}
else
{
response.Message = "Guid inválido";
}
}
catch (Exception e)
{
response.Message = $"Não foi possível receber as informações do cliente. \n {e.Message}";
}
return(response);
}
public ResponseModel Account(string id)
{
ResponseModel response = new ResponseModel();
try
{
if (GuidUtil.IsGuidValid(id))
{
User user = _userRepository.GetAccountById(Guid.Parse(id));
if (user == null)
{
response.Message = "Usuário não encotrado";
return(response);
}
ResponseAccount responseAccount = new ResponseAccount()
{
UserId = user.UserId,
Email = user.Email,
Image = user.Image,
Name = user.Name,
Roles = user.Roles,
PhoneNumbers = user.PhoneNumbers,
Locations = user.Locations,
CreateAt = user.CreatedAt
};
response.Success = true;
response.Message = "Informação básica da conta do usuário";
response.Result = responseAccount;
return(response);
}
else
{
response.Message = "Guid inválido";
}
}
catch (Exception e)
{
throw e;
}
return(response);
}
public EditEmployeeModelValidator()
{
RuleFor(x => x.UsuarioId)
.NotNull()
.NotEmpty()
.Must(id => GuidUtil.IsGuidValid(id))
.WithMessage("UserId inválido");
RuleFor(x => x.RG)
.NotNull()
.Must(rg => {
Regex rx = new Regex(@"(^\d{1,2}).?(\d{3}).?(\d{3})-?(\d{1}|X|x$)", RegexOptions.None);
return(rx.IsMatch(rg));
})
.WithMessage("CPF com formato inválido");
RuleFor(x => x.IsManager)
.NotNull()
.WithMessage("O campo IsManager não pode ser nulo");
}
public ResponseModel GetCompanyInfoPerfil(string userId)
{
ResponseModel responseModel = new ResponseModel();
if (GuidUtil.IsGuidValid(userId))
{
var company = _companyRepository.GetCompanyByUserId(Guid.Parse(userId));
if (company != null)
{
responseModel = GetCompanyComplete(company.CompanyId);
}
else
{
responseModel.Message = "Não foi possível encontrar a empresa";
}
}
else
{
responseModel.Message = "Guid inválido";
}
return(responseModel);
}
public ResponseModel GetEmployeePerfilInfo(string userId)
{
ResponseModel response = new ResponseModel();
if (GuidUtil.IsGuidValid(userId))
{
var employee = _employeeRepository.GetEmployeeByUserId(Guid.Parse(userId));
if (employee != null)
{
response = GetEmployeeInfoComplete(employee.EmployeeId);
}
else
{
response.Message = "Funciónário não encontrado";
}
}
else
{
response.Message = "Guid inválido";
}
return(response);
}
public ResponseModel AddServiceToEmployee(AddServiceToEmployeeModel model)
{
var resp = new ResponseModel();
try
{
if (model.ServicesIds != null && model.ServicesIds.Count > 0)
{
if (GuidUtil.IsGuidValid(model.EmployeeId) && model.ServicesIds.All(x => GuidUtil.IsGuidValid(x)))
{
var employee = _employeeRepository.GetEmployeeByIdWithServices(Guid.Parse(model.EmployeeId));
if (employee != null)
{
//var ess = employee.EmployeeServices;
//ess.ForEach(es => {
// _serviceEmployeeRepository.Remove(es);
//});
List <ServiceEmployee> ses = new List <ServiceEmployee>();
model.ServicesIds.ForEach(serviceId => {
var service = _serviceRepository.GetById(Guid.Parse(serviceId));
ServiceEmployee serviceEmployee = new ServiceEmployee
{
EmployeeServiceId = Guid.NewGuid(),
ServiceId = Guid.Parse(serviceId),
EmployeeId = Guid.Parse(model.EmployeeId),
Employee = employee,
Service = service,
CreatedAt = DateTimeUtil.UtcToBrasilia(),
LastUpdatedAt = DateTimeUtil.UtcToBrasilia(),
UpdatedBy = employee.UserId
};
//_serviceEmployeeRepository.Add(serviceEmployee);
ses.Add(serviceEmployee);
});
employee.EmployeeServices = ses;
_employeeRepository.Edit(employee);
resp.Success = true;
resp.Message = "Serviços adicionados ao funcionário com sucesso";
}
else
{
resp.Message = "Funcionário não encontrado";
}
}
else
{
resp.Message = "Guid inválido";
}
}
else
{
resp.Message = "Lista de serviços vazia, adicione algum serviço";
}
}
catch (Exception e)
{
resp.Message = $"Não foi possível adicionar o serviço ao funcionário: {e.Message} / {e.InnerException?.Message}";
}
return(resp);
}
public ResponseModel GetClientFavoriteEmployees(string userId)
{
ResponseModel response = new ResponseModel();
try
{
if (GuidUtil.IsGuidValid(userId))
{
var client = _clientRepository.GetClientByUserId(Guid.Parse(userId));
if (client != null)
{
List <EmployeeFavInfoModel> employeesModel = new List <EmployeeFavInfoModel>();
var employees = _employeeRepository.GetEmployeesByClientId(client.ClientId);
if (employees != null && employees.Count > 0)
{
employees.ForEach(employee =>
{
List <EmployeeFavServiceModel> serviceModels = new List <EmployeeFavServiceModel>();
var employeeServices = employee.EmployeeServices?.Select(x => x.Service).ToList();
if (employeeServices != null && employeeServices.Count > 0)
{
employeeServices.ForEach(service => {
var serviceModel = new EmployeeFavServiceModel {
ServiceId = service.ServiceId.ToString(),
ServiceName = service.Name
};
serviceModels.Add(serviceModel);
});
}
var companyModel = new CompanyFavInfoModel {
CompanyId = employee.Company?.CompanyId.ToString(),
Name = employee.Company?.User?.Name,
Email = employee.Company?.User?.Email,
Image = employee.Company?.User?.Image,
Descricao = employee?.Company?.Descricao,
Link = _companyService.GetCompanyLink(employee.CompanyId)
};
var employeeModel = new EmployeeFavInfoModel
{
EmployeeId = employee.EmployeeId.ToString(),
Link = _employeeService.GetEmployeeLink(employee.EmployeeId),
Name = employee.User.Name,
Email = employee.User.Email,
Descricao = employee.Descricao,
Image = employee.User.Image,
Services = serviceModels,
Company = companyModel
};
});
}
response.Success = true;
response.Message = "Funcionários do cliente";
response.Result = employees;
}
else
{
response.Message = "Usuário não encontrado";
}
}
else
{
response.Message = "Guid inválido";
}
}catch (Exception e)
{
response.Message = $"Não foi possível recuperar os funcionários. \n{e.Message}";
}
return(response);
}
