public async Task UpdateAsync(IEnumerable <ActModel> acts)
{
var actsDomain = acts.Adapt <IEnumerable <Act> >();
unitOfWork.ActRepository.Update(actsDomain);
await unitOfWork.ActRepository.SaveChangesAsync();
}
public void SaveData(IEnumerable <Library> libraries)
{
var libraryEntities = libraries.Adapt <IEnumerable <Entities.Library> >();
liteDbRepository.ClearTable("Libraries");
liteDbRepository.InsertData(libraryEntities, "Libraries");
}
public async Task <IActionResult> GetMentorStudents(int mentorId)
{
IEnumerable <UserNameModel> feedbackResponse = await _labService.GetMentorStudents(mentorId);
return(Ok(
feedbackResponse.Adapt <IEnumerable <UserNameResponse> >()
));
}
public async Task <IActionResult> Get()
{
IEnumerable <LabModel> labs = await _labService.GetLabs();
return(Ok(
labs.Adapt <IEnumerable <LabResponse> >()
));
}
public async Task <IActionResult> GetFeedbackQuestions(int labId)
{
IEnumerable <FeedbackQuestionModel> feedbackResponse = await _feedbackService.GetFeedbackQuestions(labId);
return(Ok(
feedbackResponse.Adapt <IEnumerable <FeedbackQuestionResponse> >()
));
}
public async Task <IActionResult> Get(int labId)
{
IEnumerable <LectureModel> schedule = await _scheduleService.GetSchedule(labId);
return(Ok(
schedule.Adapt <IEnumerable <LectureResponse> >()
));
}
public async Task <IActionResult> GivenFromSiteForm([FromBody] IEnumerable <SiteFormField> fields)
{
SiteFormModel model = null;
// Convert to Model
try
{
model = fields.Adapt <SiteFormModel>(mapper);
logger.LogInformation("Получена модель с форм сайта {@Model}", model);
}
catch (Exception ex)
{
logger.LogError(ex, "Ошибка маппинга модели данных формы с сайта {@Model}", new { Params = fields });
}
// Check Model
var validateResults = new List <ValidationResult>();
var context = new ValidationContext(model);
if (!Validator.TryValidateObject(model, context, validateResults, true))
{
foreach (var error in validateResults)
{
ModelState.AddModelError("errors", error.ErrorMessage);
}
logger.LogError("Модель не прошла валидацию - {@Errors}", validateResults.Select(e => e.ErrorMessage));
return(BadRequest(ModelState));
}
SignUpDTO dto = null;
try
{
dto = model.Adapt <SignUpDTO>();
}
catch (Exception ex)
{
logger.LogError(ex, "Ошибка маппинга модели данных формы в модель DTO {@Model}", model);
}
try
{
var result = await logic.AddLead(dto);
return(Created("", result));
}
catch (Exception ex)
{
ModelState.AddModelError("errors", ex.Message);
logger.LogError(ex, "Ошибка в логике создания сделки", model);
return(BadRequest(ModelState));
}
}
public virtual async Task <IEnumerable <TResultDto> > UpdateRange(IEnumerable <TDto> dto)
{
IEnumerable <TEntity> entities = dto.Adapt <IEnumerable <TEntity> >();
var UpdatedEntities = await _domainService.UpdateRangeAsync(entities);
IEnumerable <TResultDto> UpdateResult = UpdatedEntities.Adapt <IEnumerable <TResultDto> >();
return(UpdateResult);
}
public async void DoAction(object sender, CrmEvent e)
{
if (e.Entity != "contacts" || String.IsNullOrEmpty(e.EntityId) || e.ContactType != "contact")
{
return;
}
IEnumerable <ContactDTO> amoUser = null;
Contact contact = null;
try
{
amoUser = await amocrm.Contacts.Get().SetParam(prm => prm.Id = int.Parse(e.EntityId)).Execute();
contact = amoUser.Adapt <IEnumerable <Contact> >(mapper).FirstOrDefault();
logger.Error("Получен контакт - {Name}, {Id}", amoUser.FirstOrDefault().Name, amoUser.FirstOrDefault().Id);
}
catch (NullReferenceException ex)
{
logger.Error(ex, "Ошибка в маппинге {@Contacts}, {@AmoUser}", contact, amoUser);
}
catch (Exception ex)
{
logger.Error(ex, "Запрос пользователя amoCRM окончился неудачей. Событие - {@Event}, {@AmoUser}, {@Contacts}", e, amoUser, contact);
}
if (contact != null)
{
foreach (var phone in contact.Phones())
{
if (!(phone.Value == phone.Value.LeaveJustDigits()))
{
contact.Phones(phone.Key, phone.Value.LeaveJustDigits());
}
}
}
try
{
if (contact.ChangeValueDelegate != null)
{
var dto = contact.GetChanges().Adapt <ContactDTO>(mapper);
await amocrm.Contacts.Update(dto);
logger.Error("Сохранены очищенные телефоны для пользователя {Name}, {Id}", contact.Name, contact.Id);
}
}
catch (Exception ex)
{
var info = new MessageLocation(this)
{
Metod = MethodBase.GetCurrentMethod().Name
};
logger.Error("Ошибка, {@Message}, {@Location}", ex.Message, info);
}
}
public void AddJournalGridLessonColumn(IEnumerable <StudentMarkViewModel> marks)
{
var currentDate = DateTime.Now;
ColumnType columnType = _columnTypeRepository.FindByName("LESSON");
long columnId = _columnsRepository.AddColumn(columnType.Id, currentDate);
_columnMarksRepository.AddMarks(columnId, marks.Adapt <IEnumerable <StudentMarkModel> >());
}
private IEnumerable <EmployeeDto> MapEmployee(IEnumerable <Employee> employees)
{
var mappedEmployees = employees.Adapt <List <EmployeeDto> >();
foreach (var employeeDto in mappedEmployees)
{
employeeDto.Avatar = employeeDto.EmployeeName.FirstOrDefault().ToString();
}
return(mappedEmployees);
}
public async Task <IEnumerable <FeedbackAnswerResponseModel> > GetFeedbackAnswers(FeedbackAnswerGetRequestModel feedbackRequest)
{
FeedbackAnswerGetRequest dalFeedback = new FeedbackAnswerGetRequest(
feedbackRequest.StudentId,
feedbackRequest.MentorId,
feedbackRequest.FeedbackDateId
);
IEnumerable <FeedbackAnswerResponse> feedbackDates = await _feedbackRepository.GetFeedbackAnswers(dalFeedback);
return(feedbackDates.Adapt <IEnumerable <FeedbackAnswerResponseModel> >());
}
public async Task <IActionResult> GetFeedbackAnswers(int studentId, int mentorId, int feedbackDateId)
{
FeedbackAnswerGetRequestModel blFeedbackRequest = new FeedbackAnswerGetRequestModel(
studentId,
mentorId,
feedbackDateId
);
IEnumerable <FeedbackAnswerResponseModel> feedbackResponse = await _feedbackService.GetFeedbackAnswers(blFeedbackRequest);
return(Ok(
feedbackResponse.Adapt <IEnumerable <FeedbackAnswerResponseModel> >()
));
}
/// <summary>
/// Get api resources
/// </summary>
/// <param name="apiResources"></param>
/// <param name="context"></param>
/// <returns></returns>
public static IEnumerable <identityModels.ApiResource> GetSeedApiResources(this IEnumerable <ApiResource> apiResources, ConfigurationDbContext context)
{
var apiIndex = 1;
var scopeIndex = context.ApiResources.Count() + 1;
var dataResources = apiResources.Adapt <IEnumerable <identityModels.ApiResource> >().ToList();
foreach (var apiResource in dataResources)
{
foreach (var scope in apiResource.Scopes)
{
scope.Id = scopeIndex++;
}
apiResource.Id = apiIndex++;
yield return(apiResource);
}
}
/// <summary>
///
/// </summary>
public void StartAppAsync()
{
// Временно. Переключатель получения запроса: из файла или из кода.
GetRequestType requestType = GetRequestType.FromCode;
// Получить список запросов.
RequestFactory requestFactory = new RequestFactory();
IEnumerable <BankRequest> requests;
switch (requestType)
{
case GetRequestType.FromFile:
var requestsFileName = Path.Combine(Directory.GetCurrentDirectory(), @"AspApp\Models\Requests.json");
//@"D:\Projects\RatesParsing\RatesParsingConsole\RatesParsingConsole\AspApp\Models\Requests.json";
requests = requestFactory.GetBankRequestsFromFile(requestsFileName);
break;
case GetRequestType.FromCode:
requests = requestFactory.GetBankRequestsFromCode();
break;
default:
requests = Array.Empty <BankRequest>();
break;
}
// Передать данные запроса в консольное приложение и получить результаты.
// В процессе конвертировать данные из domain в dto и при получении произвести обратную конвертацию: из dto в domain.
ConsoleHome consoleHome = new ConsoleHome();
var requestsDto = requests.Adapt <IEnumerable <BankRequestDto> >();
// Применена конструкция .Result, так как применение await требует соответственно сделать входной метод Program.Main(), что недопустимо в текущей версии языка.
IEnumerable <BankRatesDto> banksDto = consoleHome.GetBankRatesAsync(requestsDto).Result;
var banks = banksDto.Adapt <IEnumerable <BankRates> >();
// Получить данные курсов по банкам синхронно.
//IEnumerable<BankRatesDto> banks = consoleHome.GetBankRates(requests);
// Вывести полученные значения.
var publishResults = new PublishResults();
//publishResults.ShowExchangeRates(banks);
publishResults.WriteToFileAsync(banks);
publishResults.SerializeToJsonFile(banks).Wait();
}
public async Task <IActionResult> Post([ModelBinder(typeof(EventsModelBinder))] IEnumerable <EventViewModel> value)
{
logger.LogDebug("FirstDVS | Событие AmoCRM [ {Entity} | {Event} ] -- Model {@model}", value.First().Entity, value.First().Event, value.First());
try
{
var model = value.Adapt <IEnumerable <EventDTO> >(mapper);
await logic.EventsHandle(model);
}
catch (Exception ex)
{
logger.LogWarning(ex, "Ошибка обработки модели {@model}", value);
return(StatusCode(500));
}
return(Ok());
}
/// <summary>
/// Сохранить проект как.
/// </summary>
public static async Task SaveAsAsync(IEnumerable <IMatchingResult> matchingResult, IProjectProperties projectProperties)
{
try
{
var fileModel = new WorkProjectFileModel()
{
MatchingResults = matchingResult.Adapt <IEnumerable <MatchingResultFile> >(),
ProjectProperties = projectProperties.Adapt <ProjectPropertiesFile>()
};
// Поток записи в файл
using var fileStream = new FileStream(projectProperties.ProjectFilePath, FileMode.OpenOrCreate);
using var zipStream = new GZipStream(fileStream, CompressionLevel.Optimal);
await JsonSerializer.SerializeAsync(zipStream, fileModel);
}
catch (Exception ex)
{
MessageBox.Show($"Ошибка при записи в файл: {ex.Message}", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public async Task <IEnumerable <FeedbackQuestionModel> > GetFeedbackQuestions(int labId)
{
IEnumerable <FeedbackQuestion> feedbackDates = await _feedbackRepository.GetFeedbackQuestions(labId);
return(feedbackDates.Adapt <IEnumerable <FeedbackQuestionModel> >());
}
public async Task <IEnumerable <RespuestaOrden> > ObtenerTodos()
{
IEnumerable <Orden> ordenes = await _unidadDeTrabajo.Ordenes.ObtenerTodos();
return(ordenes.Adapt <IEnumerable <RespuestaOrden> >());
}
protected virtual IEnumerable <TModel> MapToModel(IEnumerable <TEntity> entities)
{
return(entities.Adapt <IEnumerable <TModel> >());
}
public async void DoAction(object sender, CrmEvent e)
{
if (e.Entity != "contacts" || String.IsNullOrEmpty(e.EntityId) || e.ContactType != "contact")
{
return;
}
IEnumerable <ContactDTO> amoUser = null;
Contact contact = null;
try
{
var id = int.Parse(e.EntityId);
amoUser = await crm.Contacts.Get().Filter(f => f.Id = id).Execute();
if (amoUser == null)
{
throw new NullReferenceException("Контакт [ Id -" + e.EntityId + " ] не найден в CRM");
}
contact = amoUser.Adapt <IEnumerable <Contact> >(mapper).FirstOrDefault();
}
catch (NullReferenceException ex)
{
currentLogger.LogDebug(ex, "Ошибка, нулевое значение {@Contacts}", contact, amoUser);
return;
}
catch (ArgumentNullException ex)
{
currentLogger.LogDebug(ex, "Ошибка (int) конвертации ID {@Contact}", contact);
return;
}
catch (Exception ex)
{
currentLogger.LogDebug(ex, "Запрос пользователя amoCRM окончился неудачей. Событие - {@Event}, {@AmoUser}", e, amoUser, contact);
return;
}
foreach (var phone in contact.Phones())
{
if (!(phone.Value == phone.Value.LeaveJustDigits()))
{
contact.Phones(phone.Key, phone.Value.LeaveJustDigits());
}
}
try
{
if (contact.ChangeValueDelegate != null)
{
var dto = contact.GetChanges().Adapt <ContactDTO>(mapper);
await crm.Contacts.Update(dto);
currentLogger.LogInformation("Обновление Phone для пользователя Id - {User}", contact.Id);
}
}
catch (Exception ex)
{
currentLogger.LogDebug(ex, "Ошибка обновления пользователя. [{@Id}]", contact.Id);
}
}
/// <summary>
/// Convert an <see cref="IEnumerable{TEntity}"/> to a <see cref="TDto"/> array.
/// </summary>
/// <param name="entities">The <see cref="IEnumerable{TEntity}"/>.</param>
protected TDto[] Adapt(IEnumerable <TEntity> entities)
{
return(entities.Adapt <TDto[]>());
}
public async Task <IEnumerable <LabModel> > GetLabs()
{
IEnumerable <Lab> labs = await _labRepository.GetLabs();
return(labs.Adapt <IEnumerable <LabModel> >());
}
public IEnumerable <TDto> Map(IEnumerable <TEntity> input) => input.Adapt <IEnumerable <TDto> >();
public async Task <IEnumerable <UserNameModel> > GetMentorStudents(int mentorId)
{
IEnumerable <UserName> feedbackDates = await _labRepository.GetStudentByMentorId(mentorId);
return(feedbackDates.Adapt <IEnumerable <UserNameModel> >());
}
public async Task <IEnumerable <RespuestaArticulo> > ObtenerTodos()
{
IEnumerable <Articulo> articulos = await _unidadDeTrabajo.Articulos.ObtenerTodos();
return(articulos.Adapt <IEnumerable <RespuestaArticulo> >());
}
public async Task <IEnumerable <LectureModel> > GetSchedule(int labId)
{
IEnumerable <Lecture> schedule = await _scheduleRepository.GetSchedule(labId);
return(schedule.Adapt <IEnumerable <LectureModel> >());
}
public IEnumerable <UniversityDto> Map(IEnumerable <University> source)
{
return(source.Adapt <IEnumerable <UniversityDto> >());
}
public IEnumerable <T2> Map(IEnumerable <T1> values)
{
return(values.Adapt <IEnumerable <T2> >());
}
/// <summary>
/// Convert an <see cref="IEnumerable{TDto}"/> to a <see cref="TEntity"/> array.
/// </summary>
/// <param name="dtos">The <see cref="IEnumerable{TDto}"/>.</param>
protected TEntity[] Adapt(IEnumerable <TDto> dtos)
{
return(dtos.Adapt <TEntity[]>());
}
