public IActionResult Create(ProjectsVm ProjectsVm) { logger.LogDebug($"Project.Create [post] is called"); try { if (ProjectsVm.Projects == null) { throw new ArgumentException(); } if (ModelState.IsValid) { ProjectDto projectDto = ConvertToProjectDto.Convert(ProjectsVm.Projects); ProjectService.Create(projectDto); } else { return(View(ProjectsVm)); } } catch (Exception ex) { logger.LogError(ex.Message); return(View("Error")); } return(RedirectToAction(nameof(Index))); }
public IActionResult Create(ProjectTaskFilledVm projectTaskFilledVm) { logger.LogDebug($"ProjectTask.Create [post] is called"); try { if (projectTaskFilledVm == null) { throw new ArgumentException("Variable shuld not be null", nameof(projectTaskFilledVm)); } if (ModelState.IsValid) { ProjectTaskDto projectTaskDto = ConvertToProjectTaskDto.Convert(projectTaskFilledVm.ProjectTasks); ProjectTaskService.Create(projectTaskDto); } else { return(View(projectTaskFilledVm)); } } catch (Exception ex) { logger.LogError(ex.Message); return(View("Error")); } return(RedirectToAction(nameof(Index))); }
public void Create(EmployeeDto item) { logger.LogDebug(this.GetType() + ".Create is called"); Employee Employee = EmployeeConverter.Convert(item); EmployeeRepository.Create(Employee); }
public ProjectDto Get(int id) { logger.LogDebug(this.GetType() + ".Get is called"); Project Project = ProjectRepository.GetSingle(id); return(ProjectDtoConverter.Convert(Project)); }
public IList <ProjectTaskDto> GetAll() { IList <ProjectTask> ProjectTasks = ProjectTaskRepository.GetAll(); IList <ProjectTaskDto> ProjectTasksDto = ProjectTaskDtoConverter.Convert(ProjectTasks); return(ProjectTasksDto); }
public void Create(ProjectDto item) { logger.LogDebug(this.GetType() + ".Create is called"); Project Project = ProjectConverter.Convert(item); ProjectRepository.Create(Project); }
public IActionResult Create(EmployeeVm employee) { logger.LogDebug($"Employee.Create [post] is called"); try { if (employee == null) { throw new ArgumentException("Variable shuld not be null", nameof(employee)); } if (ModelState.IsValid) { EmployeeService.Create(ConvertToEmployeeDto.Convert(employee)); } else { return(View(employee)); } } catch (Exception ex) { logger.LogError(ex.Message); return(View("Error")); } return(RedirectToAction(nameof(Index))); }
public IActionResult Index() { logger.LogDebug($"Project.Index is called"); IList <ProjectVm> Projects = ConvertToProjectVm.Convert(ProjectService.GetAll()); return(View(Projects)); }
public IActionResult Index() { logger.LogDebug($"ProjectTask.Index is called"); IList <ProjectTaskVm> ProjectTasksVm = ConvertToProjectTaskVm.Convert(ProjectTaskService.GetAll()); FillProjectTasksVm(ProjectTasksVm); return(View(ProjectTasksVm)); }
public EmployeeDto Get(int id) { logger.LogDebug(this.GetType() + ".Get is called"); Employee Employee = EmployeeRepository.GetSingle(id); EmployeeDto EmployeeDto = EmployeeDtoConverter.Convert(Employee); return(EmployeeDto); }
public IActionResult Index() { logger.LogDebug($"Employee.Index is called"); IList <EmployeeDto> EmployeesDto = EmployeeService.GetAll(); List <EmployeeVm> EmployeesVm = new List <EmployeeVm>(); foreach (var item in EmployeesDto) { EmployeesVm.Add(ConvertToEmployeeVm.Convert(item)); } return(View(EmployeesVm)); }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { _logger.LogInformation(LogInfo.ServiceStarted, "Worker started at: {time}", DateTimeOffset.Now); while (!stoppingToken.IsCancellationRequested) { var data = (await _parser.GetData(_settings.uri)).ToList(); var count = data.Count(); _logger.LogInformation(LogInfo.DataParsed, "Parser get {count} entries", count); if (count > 0) { var processedData = data.AsParallel().Select(x => _converter.Convert(x)).ToList(); _logger.LogInformation(LogInfo.DataParsed, "Plaintext data converted to objects"); await _writer.WriteAll(processedData); _logger.LogInformation(LogInfo.DataWritten, "Worker writed at: {time}", DateTimeOffset.Now); } else { _logger.LogCritical(LogInfo.Error, "No data parsed"); } await Task.Delay(30 * 1000, stoppingToken); } _logger.LogInformation(LogInfo.ServiceStopped, "Worker stopped at: {time}", DateTimeOffset.Now); }
internal static object[] Convert(string[] objects, ParameterInfo[] wantedTypes, IPlayer invoker, bool withOptional = false, string debug = "") { try { Wrapper.Server.Logger.Debug(debug + ": " + JsonConvert.SerializeObject(objects)); object[] arr = new object[wantedTypes.Length]; arr[0] = invoker; for (int i = 1; i < wantedTypes.Length; i++) { ParameterInfo wantedType = wantedTypes[i]; if (withOptional && wantedType.IsOptional && (i - 1) >= objects.Length) { arr[i] = Type.Missing; continue; } IConvert convert = FindConvert(wantedType.ParameterType); if (convert != null) { arr[i] = convert.Convert(objects[i - 1], wantedType.ParameterType); } } return(arr); } catch (Exception e) { Wrapper.Server.Logger.Error("An error occurred in converting process!", e); return(null); } }
private async Task <Stats> LoadStats(Guid chapterId, Guid profileId, int pages) { var stats = await _database.QueryStats(chapterId, profileId) ?? await _stats.Add(DbStats.Create(profileId, chapterId, pages)); return(_convertStats.Convert(stats)); }
public IActionResult Edit(int id) { logger.LogDebug($"Project.Edit [get] is called"); ProjectVm ProjectVm = ConvertToProjectVm.Convert(ProjectService.Get(id)); IList <ProjectTaskVm> ProjectTasksVm = ConvertToProjectTaskVm.Convert(ProjectTaskService.GetAllByProjectId(ProjectVm.Id)); ProjectsVm model = ComposeProjectVm(ProjectVm, ProjectTasksVm); return(View("CreateOrEdit", model)); }
private static void Test(IConvert convert, ConvertType ctype) { A2 obj = new A2 { Id = 1, Name = "A1" }; A1 obj2 = convert.Convert <A2, A1>(obj); Show(obj, obj2, ctype); }
public async Task <Stats> Stats(Guid profileId, Guid chapterId) { var profile = await _profiles.Get(profileId, UserId); var stats = await _database.QueryStats(chapterId, profile.Id); stats.Validate(); return(_stats.Convert(stats)); }
public object ProcessRequest(byte[] requestBytes, IPAddress address, WebSocket socket) { var requestAsString = _toStringConverter.Convert(requestBytes); try { var json = JObject.Parse(requestAsString); var type = json["type"].ToString(); var payload = json["payload"].ToString(); switch (type) { case "clientOffer": var clientOfferRequest = new ClientOfferRequest(address, socket, payload); var clientOfferRequestHandler = _handlersFactory.Create(clientOfferRequest, clientOfferRequest.GetResponseType()); return(clientOfferRequestHandler.Handle(clientOfferRequest)); case "serverOffer": var serverRequest = new ServerOfferRequest(address, socket, payload); var serverRequestHandler = _handlersFactory.Create(serverRequest, serverRequest.GetResponseType()); return(serverRequestHandler.Handle(serverRequest)); case "answer": var answerRequest = new AnswerRequest(address, socket, payload); var answerRequestHandler = _handlersFactory.Create(answerRequest, answerRequest.GetResponseType()); return(answerRequestHandler.Handle(answerRequest)); case "new-ice": var newICERequest = new NewICEAvailableRequest(address, socket, payload); var newICERequestHandler = _handlersFactory.Create(newICERequest, newICERequest.GetResponseType()); return(newICERequestHandler.Handle(newICERequest)); case "txt": default: var txtRequest = new TxtRequest(address, socket, payload); var txtRequestHandler = _handlersFactory.Create(txtRequest, txtRequest.GetResponseType()); return(txtRequestHandler.Handle(txtRequest)); } } catch (System.Exception ex) { return($@"An error {ex} occured."); } }
public void Encode(string sourceFile) { var sourceToken = _jsonFileProcessor.Load(sourceFile); var gameToken = _gameConverter.Convert(sourceToken); var relativeFile = DirectoryHelper.MakeRelative(SourcePath, sourceFile); var gameFile = Path.GetFullPath(Path.Combine(GamePath, relativeFile)); gameFile = Path.ChangeExtension(gameFile, "rxdata"); DirectoryHelper.EnsureDirectoryExists(Path.GetDirectoryName(gameFile)); _rubyEncoder.Encode(gameToken, gameFile, EncoderOptions); }
public void Decode(string gameFile) { var gameToken = _rubyEncoder.Decode(gameFile, DecoderOptions); var sourceToken = _sourceConverter.Convert(gameToken); var relativeFile = DirectoryHelper.MakeRelative(GamePath, gameFile); var sourceFile = Path.GetFullPath(Path.Combine(SourcePath, relativeFile)); sourceFile = Path.ChangeExtension(sourceFile, "json"); DirectoryHelper.EnsureDirectoryExists(Path.GetDirectoryName(sourceFile)); _jsonFileProcessor.Save(sourceToken, sourceFile); }
private void Run() { while (true) { var line = io.Read(); if (!string.IsNullOrWhiteSpace(line)) { if (string.Equals(line, "STOP", StringComparison.InvariantCultureIgnoreCase)) { return; } var result = converter.Convert(line); io.Write(result); } } }
private ActionResult processRequest(string textToParse, string fileName, IConvert converter) { if (textToParse != null) { Parser parser = new Parser(); Text text = parser.Parse(textToParse); string result = converter.Convert(text); byte[] fileBytes = Encoding.UTF8.GetBytes(result); return(File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Octet, fileName)); } else { ModelState.AddModelError("text", "Please enter text"); return(View()); } }
public async Task <Profile> Get(Guid profileId, string userId) { var profile = await _cache.GetOrAddAsync(profileId.ToString(), async() => _converter.Convert(await _profiles.Get(profileId))); if (profile == null) { throw new NotFoundException($"Profile for ID {profileId} not found."); } if (profile.UserId != userId) { throw new UnauthorizedException($"Access to Profile {profileId} denied."); } return(profile); }
/// <summary> /// Converts the given objects into it wanted types. /// </summary> /// <param name="objects">The given objects</param> /// <param name="wantedTypes">The wanted types</param> public static object[] Convert(string[] objects, Type[] wantedTypes) { object[] arr = new object[objects.Length]; for (int i = 0; i < objects.Length; i++) { Type wantedType = wantedTypes[i]; string obj = objects[i]; IConvert convert = FindConvert(wantedType); if (convert != null) { try { arr[i + 1] = convert.Convert(obj, wantedType); } catch (Exception e) { Wrapper.Server.Logger.Error("An error occurred while converting " + obj + " to " + wantedType.FullName + "!", e); } } } return(arr); }
/// <summary> /// Converts between versions of the IFC schema, upwards or downwards. /// </summary> /// <param name="sourceObject">Ths source object (use IfcProject to capture everything), which must be of the sourceType indicated in the constructor.</param> /// <returns>The new object that has been converted to the targetType indicated in the constructor.</typeparam></returns> public object Convert(object sourceObject) { // copy over fields and trace dependencies ObjectIDGenerator gen = new ObjectIDGenerator(); Dictionary <object, object> mapInstances = new Dictionary <object, object>(); // map from object from source schema to object in target schema Dictionary <object, object> mapChanges = new Dictionary <object, object>(); // map from object from source schema to converted object in source schema Queue <object> qRoot = new Queue <object>(); qRoot.Enqueue(sourceObject); while (qRoot.Count > 0) { // process the queue object o = qRoot.Dequeue(); object oReplacement = o; // allocate target object Type typeSource = o.GetType(); Type typeTarget = this.m_adapterTarget.GetType(typeSource.Name); // heal any objects first (before transforming) Type t = typeSource.BaseType; while (t != typeof(object)) { IConvert healer = null; if (this.m_mapHealers.TryGetValue(t, out healer)) { healer.Convert(o, t); } t = t.BaseType; } Type typeOverride = null; if (this.m_mapTypes != null && this.m_mapTypes.TryGetValue(typeSource, out typeOverride)) { typeTarget = typeOverride; // pre-convert, such as for geometry (may or may not convert to within the same IFC version) IConvert typeconverter = null; if (this.m_mapConverters != null && this.m_mapConverters.TryGetValue(typeSource, out typeconverter)) { oReplacement = typeconverter.Convert(o, typeTarget); if (oReplacement != null) { mapChanges.Add(o, oReplacement); typeSource = oReplacement.GetType(); typeTarget = this.m_adapterTarget.GetType(typeSource.Name); } } else { typeTarget = this.m_adapterTarget.GetType(typeOverride.Name); } } if (typeTarget == null || typeTarget.IsAbstract || oReplacement == null) { mapInstances.Add(o, null); // record null to void future conversion, report what didn't convert } else { object target = Activator.CreateInstance(typeTarget); // map it immediately mapInstances.Add(o, target); bool firstTime; long id = gen.GetId(o, out firstTime); IList <PropertyInfo> fieldsDirect = this.m_adapterSource.GetDirectFields(oReplacement.GetType()); foreach (PropertyInfo field in fieldsDirect) { if (field != null && !field.PropertyType.IsValueType) { object inval = field.GetValue(oReplacement); if (inval is IEnumerable) { IEnumerable list = (IEnumerable)inval; foreach (object oival in list) { if (oival != null && !oival.GetType().IsValueType&& !(oival is string)) { gen.GetId(oival, out firstTime); if (firstTime) { qRoot.Enqueue(oival); } } } } else if (inval is object) { if (inval != null && !inval.GetType().IsValueType&& !(inval is string)) { gen.GetId(inval, out firstTime); if (firstTime) { qRoot.Enqueue(inval); } } } } } // capture inverse fields -- don't use properties, as those will allocate superflously IList <PropertyInfo> fields = this.m_adapterSource.GetInverseFields(oReplacement.GetType()); foreach (PropertyInfo field in fields) { object inval = field.GetValue(oReplacement); if (inval is IEnumerable) { IEnumerable list = (IEnumerable)inval; foreach (object oival in list) { gen.GetId(oival, out firstTime); if (firstTime) { qRoot.Enqueue(oival); } } } else if (inval is object) { gen.GetId(inval, out firstTime); if (firstTime) { qRoot.Enqueue(inval); } } } } } // populate fields foreach (object o in mapInstances.Keys) { object target = mapInstances[o]; if (target != null) { object source = null; if (!mapChanges.TryGetValue(o, out source)) { source = o; } IList <PropertyInfo> fieldsSource = this.m_adapterSource.GetDirectFields(source.GetType()); IList <PropertyInfo> fieldsTarget = this.m_adapterTarget.GetDirectFields(target.GetType()); for (int iField = 0; iField < fieldsSource.Count && iField < fieldsTarget.Count; iField++) { PropertyInfo fieldSource = fieldsSource[iField]; PropertyInfo fieldTarget = fieldsTarget[iField]; if (fieldSource != null && fieldTarget != null) // null if derived { object valueSource = fieldSource.GetValue(source); if (valueSource != null) { object valueTarget = ConvertValue(valueSource, fieldTarget.PropertyType, mapInstances); if (valueTarget != null) { fieldTarget.SetValue(target, valueTarget); this.m_adapterTarget.UpdateInverseReferences(target, fieldTarget, valueTarget); } } else if (fieldTarget.PropertyType.IsEnum && !fieldTarget.PropertyType.IsGenericType) // if non-nullable enum, must populate { object valueTarget = null; // use NOTDEFINED if provided, otherwise pick first constant // (e.g. IfcSpatialStructureElement.ElementCompositionType is required in IFC2x3, optional in IFC4, and there's no NOTDEFINED value) --> ELEMENT should be used in such case FieldInfo[] fieldConstants = fieldTarget.PropertyType.GetFields(BindingFlags.Public | BindingFlags.Static); foreach (FieldInfo fieldConst in fieldConstants) { Enum enumvalue = (Enum)fieldConst.GetValue(null); int intvalue = (int)System.Convert.ChangeType(enumvalue, enumvalue.GetTypeCode()); if (intvalue == 0) { valueTarget = enumvalue; break; } } valueTarget = fieldConstants[0].GetValue(null); fieldTarget.SetValue(target, valueTarget); } } } // populate any required fields on target object //for (int iField = 0; iField < fieldsTarget.Count; iField++) //{ //} } } return(mapInstances[sourceObject]); }
public void Create(ProjectTaskDto item) { ProjectTask ProjectTask = ProjectTaskConverter.Convert(item); ProjectTaskRepository.Create(ProjectTask); }