/// <summary>
/// Create zone Records
/// </summary>
/// <param name="uuid">The uuid of the zone</param>
/// <param name="record">the record data </param>
/// <returns>an error code and the json response</returns>
public ZoneUpdateResponse CreateRecords(string uuid, RecordDto record)
{
Task <ZoneUpdateResponse> task = Task.Run(async() => await CreateRecordsAsync(uuid, record));
task.Wait();
return(task.Result);
}
public List <RecordDto> GetDtosByItemBaseOnHardwareID(int id)
{
List <RecordDto> recordDtos = new List <RecordDto>();
var records = _recordRepository.GetRecordsByItemBaseOnHardwareID(id);
foreach (var record in records)
{
RecordDto recordDto = new RecordDto();
recordDto.ID = record.ID;
recordDto.UpdateTime = record.UpdateTime;
recordDto.UpdateUser = record.UpdateUser;
recordDto.Remark = record.Remark;
if (record.Status == 0)
{
recordDto.Status = "未测试";
}
else if (record.Status == 1)
{
recordDto.Status = "正常";
}
else if (record.Status == 2)
{
recordDto.Status = "异常";
}
recordDtos.Add(recordDto);
}
return(recordDtos);
}
public override void OnNavigatingTo(NavigationParameters parameters)
{
m_Record = (RecordDto)parameters["model"];
m_Group = (GroupDto)parameters["group"];
RaisePropertyChanged(nameof(TrackCost));
RaisePropertyChanged(nameof(GroupID));
RaisePropertyChanged(nameof(ID));
RaisePropertyChanged(nameof(RecordTitle));
RaisePropertyChanged(nameof(Cost));
foreach (var u in m_Group.Users)
{
UsersForRecord.Add(u);
}
if (m_Record.UserID != Guid.Empty)
{
SelectedIndex = UsersForRecord.IndexOf(UsersForRecord.FirstOrDefault(x => x.ID == m_Record.UserID));
}
RaisePropertyChanged("UserName");
if (parameters["alert"] != null)
{
Acr.UserDialogs.ToastConfig config = new Acr.UserDialogs.ToastConfig(parameters["alert"].ToString());
config.BackgroundColor = System.Drawing.Color.Green;
Acr.UserDialogs.UserDialogs.Instance.Toast(config);
}
}
/// <summary>
/// Create domain Records
/// </summary>
/// <param name="fqdn">The fqdn of the domain</param>
/// <param name="record">the record data </param>
/// <returns>an error code and the json response</returns>
public DomainUpdateResponse CreateRecords(string fqdn, RecordDto record)
{
Task <DomainUpdateResponse> task = Task.Run(async() => await CreateRecordsAsync(fqdn, record));
task.Wait();
return(task.Result);
}
public IEnumerable <ModuleDto> Get()
{
var xs = _session.Query <Module>();
IList <ModuleDto> lst = new List <ModuleDto>();
foreach (Module node in xs)
{
var dto = new ModuleDto
{
Id = node.Id,
Name = node.Name
};
foreach (Record r in node.Records)
{
RecordDto rDto = new RecordDto
{
Id = r.Id,
Name = r.Name,
Content = r.Content,
};
dto.Records.Add(rDto);
dto.RecordsCount++;
}
lst.Add(dto);
}
return(lst);
}
/// <summary>
/// Create zone Records asynchronously
/// </summary>
/// <param name="uuid">The uuid of the zone</param>
/// <param name="record">the record data </param>
/// <returns>an error code and the json response</returns>
public async Task <ApiResponse> CreateRecordsAsync(string uuid, RecordDto record)
{
StringContent content = new StringContent(JsonConvert.SerializeObject(record), Encoding.Default, "application/json");
string request = $"zones/{uuid}/records";
return(await RequestPostAsync(request, content));
}
public async void AddRecord(RecordDto model)
{
//Get timing
var currenLabel = await _iSettingService.GetSettingHourly();
RecordViewModel record = new RecordViewModel();
record.Date_Time = DateTime.Now;
record.Hourly_Label = "";
record.Worker_ID_Collect_Data = model.Operator != null?model.Operator.Trim() : "";
record.Model_Name = model.Name != null?model.Name.Trim() : "";
record.Model_Number = model.Num != null?model.Num.Trim() : "";
record.Hourly_Label = currenLabel.label.ToString();
if (!model.C.IsNullOrEmpty() && !model.A.IsNullOrEmpty())
{
record.Prod_Cell = model.C != null?model.C.Trim() : "";
record.Article_Number = model.A != null?model.A.Trim() : "";
record.Prod_Cell_Main = _iMesService.GetAllArticle(model.C).Result.Find(x => x.Trim() == model.A) == null ? model.CO : "";
}
var recordData = _mapper.Map <Record>(record);
_recordRepository.Add(recordData);
await _recordRepository.SaveAll();
}
public ModuleDto Get(int id)
{
using (var transaction = _session.BeginTransaction())
{
var node = _session.Get <Module>(id);
if (node == null)
{
return(null);
}
var dto = new ModuleDto
{
Name = node.Name,
Id = node.Id,
};
foreach (Record r in node.Records)
{
RecordDto rDto = new RecordDto
{
Id = r.Id,
Name = r.Name,
Content = r.Content,
};
dto.Records.Add(rDto);
}
return(dto);
}
}
public RecordDto PostRecordCounts(ContactInfoDto contactInfoDto)
{
RecordDto recordDto = new RecordDto();
recordDto = _contactInfoDtoManager.GetRecordUserCount(contactInfoDto.Address);
return(recordDto);
}
public async Task <RecordDto> UpdateRecord(RecordDto updateRecord, string userId)
{
//Only allows the same user to update its own record
var existingRecord = await unitOfWork.RecordRepository.GetFirstOrDefault(r => r.Id == updateRecord.Id && r.UserId == Convert.ToInt64(userId));
if (existingRecord == null)
{
throw new Exception("Invalid request");
}
//Only update these fields
existingRecord.Content = updateRecord.Content;
existingRecord.Title = updateRecord.Title;
if (updateRecord.RecordVisibilityId > 0)
{
existingRecord.RecordVisibilityId = updateRecord.RecordVisibilityId;
}
await unitOfWork.RecordRepository.Update(existingRecord);
await unitOfWork.Save();
var recordDto = mapper.Map <RecordDto>(existingRecord);
return(recordDto);
}
public async Task <List <RecordDto> > GetRandomPrizeRecords(int prizeID, int numberOfSpinAreas)
{
var flag = true;
var currentQty = 0;
var result = new List <RecordDto>();
var models = new List <Record>();
while (flag)
{
var emp = await _empRepository.FindAll(x => x.EmpCode != null).OrderBy(x => Guid.NewGuid()).FirstOrDefaultAsync();
if (emp == null)
{
continue;
}
var isWinner = await _recordRepository.FindAll().AnyAsync(x => x.EmpCode == emp.EmpCode);
if (isWinner)
{
continue;
}
var model = new Record
{
EmpCode = emp.EmpCode,
PrizeID = prizeID,
Visible = true
};
models.Add(model);
currentQty += 1;
var record = new RecordDto
{
EmpCode = emp.EmpCode,
PrizeID = prizeID,
Visible = true,
EmpDept = emp.EmpDept,
EmpName = emp.EmpName
};
result.Add(record);
if (currentQty == numberOfSpinAreas)
{
flag = false;
}
}
_recordRepository.AddMultiple(models);
try
{
await _recordRepository.Save();
return(result);
}
catch (System.Exception)
{
return(new List <RecordDto>());
}
}
public RecordDto Add(RecordDto item)
{
Record record = _mapper.Map <Record>(item);
_dbContext.Record.Add(record);
_dbContext.SaveChanges();
return(GetDto(record.Id));
}
public async Task <RecordDto> CrawlWebsiteAsync(string startUrl, BlockingCollection <RecordItemDto> blockingCollection, CancellationToken cancellationToken)
{
if (!Uri.IsWellFormedUriString(startUrl, UriKind.Absolute))
{
throw new UriFormatException("Url in not valid");
}
var startUri = new Uri(startUrl, UriKind.Absolute);
var stopwath = new Stopwatch();
var visitedUri = new List <Uri>();
var pagesToBeCalled = new Queue <Uri>();
var result = new RecordDto();
pagesToBeCalled.Enqueue(startUri);
// TODO: Extract to factory service
result.RequestedUrl = startUrl;
result.RecordCreated = DateTime.UtcNow;
result.Items = new List <RecordItemDto>();
while (pagesToBeCalled.Any() && !cancellationToken.IsCancellationRequested)
{
var recordItem = new RecordItemDto();
var currentUri = pagesToBeCalled.Dequeue();
stopwath.Reset();
stopwath.Start();
var requestResult = await client.GetAsync(currentUri.AbsoluteUri);
var content = await requestResult.Content.ReadAsStringAsync();
stopwath.Stop();
visitedUri.Add(currentUri);
recordItem.RequestUrl = currentUri.AbsolutePath;
recordItem.RequestTime = stopwath.Elapsed;
result.Items.Add(recordItem);
blockingCollection.Add(recordItem);
var parsedUrls = htmlParser.GetUrlsFromHtmlATag(content);
var filteredPaths = urlFilter.RemoveUnnecessary(parsedUrls, currentUri);
foreach (var parsedUri in filteredPaths)
{
if (!visitedUri.Contains(parsedUri) && !pagesToBeCalled.Contains(parsedUri))
{
pagesToBeCalled.Enqueue(parsedUri);
}
}
}
blockingCollection.CompleteAdding();
return(result);
}
/// <summary>
/// Create zone Records asynchronously
/// </summary>
/// <param name="uuid">The uuid of the zone</param>
/// <param name="record">the record data </param>
/// <returns>an error code and the json response</returns>
public async Task <ZoneUpdateResponse> CreateRecordsAsync(string uuid, RecordDto record)
{
ApiResponse resp = await _client.CreateRecordsAsync(uuid, record);
ZoneUpdateResponse retour = new ZoneUpdateResponse();
retour.Load(resp);
return(retour);
}
/// <summary>
///
/// </summary>
/// <param name="User"></param>
public void InsertRecord(RecordDto User)
{
var record = Current.Records.LastOrDefault();
User.Id = ++record.Id;
RecordData.Current.Records.Add(User);
}
/// <summary>
/// Create domain Records asynchronously
/// </summary>
/// <param name="fqdn">The fqdn of the domain</param>
/// <param name="record">the record data </param>
/// <returns>an error code and the json response</returns>
public async Task <DomainUpdateResponse> CreateRecordsAsync(string fqdn, RecordDto record)
{
ApiResponse resp = await _client.CreateRecordsAsync(fqdn, record);
DomainUpdateResponse retour = new DomainUpdateResponse();
retour.Load(resp);
return(retour);
}
public async Task UpdateARecord(DomainSummaryDto domain, RecordDto record, int ttl, string ip)
{
var content = new StringContent(JsonConvert.SerializeObject(new
{
ttl = ttl,
data = ip
}), Encoding.UTF8, "application/json");
await this.PutAsync($"https://api.godaddy.com/v1/domains/{domain.Domain}/records/A/{record.Name}", content);
}
private void ValidateRecordWork(RecordDto dto)
{
int parse;
var check = Int32.TryParse(dto.Value, out parse);
if (!check || dto.WorkId == null)
{
throw new BusinessException("Invalid parameter!", ErrorCode.INVALID_PARAMETER);
}
}
public bool SaveRecord(RecordDto recordDto)
{
return(_recordRepository.InsertRecord(new Data.RecordEntity()
{
LastName = recordDto.LastName,
FirstName = recordDto.FirstName,
Gender = recordDto.Gender,
DateOfBirth = Convert.ToDateTime(recordDto.DateOfBirth),
FavoriteColor = recordDto.FavoriteColor
}));
}
public IActionResult Add([FromBody] RecordDto record)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_recordRepository.Add(record);
return(Ok());
}
public RecordBl(RecordDto dto)
{
if (dto != null)
{
Id = dto.Id;
UserId = dto.UserId;
RecordDate = dto.RecordDate;
User = new UserBl(dto.User);
Check = new CheckBl(dto.Check);
Record2Procedure = dto.Record2Procedure;
}
}
public RecordDto GetRecordUserCount(string location)
{
List <int> reportList = uof.contactInfoRepository.GetRecordUserCount(location);
RecordDto recordDto = new RecordDto();
recordDto.recordUsersCount = reportList[0];
recordDto.recordNumberCount = reportList[1];
recordDto.Location = location;
return(recordDto);
}
public ActionResult <RecordDto> AddNewUserRecord([FromBody] RecordDto dto)
{
try
{
var item = _bl.AddNewUserRecord(dto);
return(CreatedAtRoute("GetRecordById", new { Id = item.Id }, item));
}
catch (Exception ex)
{
return(Conflict(ex.Message));
}
}
public async Task NewRecord(RecordDto shout)
{
try
{
var response = await PostAsJsonAsync(client, "api/records", shout);
response.EnsureSuccessStatusCode();
}
catch (Exception)
{
return;
}
}
/// <summary>
/// Private method to send request to service layer
/// </summary>
/// <param name="User"></param>
private void InsertRecord(string[] User)
{
var finalRecord = new RecordDto()
{
FirstName = User[0],
LastName = User[1],
DOB = Convert.ToDateTime(User[2].ToString()),
Color = User[4],
Gender = User[3]
};
_recordService.Add(finalRecord);
}
/// <summary>
///
/// </summary>
/// <param name="User"></param>
/// <returns></returns>
public Boolean Add(string[] User)
{
var _record = new RecordDto()
{
FirstName = User[0],
LastName = User[1],
DOB = Convert.ToDateTime(User[2].ToString()),
Color = User[3],
Gender = User[4]
};
_datalayer.InsertRecord(_record);
return(true);
}
public ActionResult <RecordDto> Update([FromBody] RecordDto dto)
{
try
{
return(_bl.Update(dto));
}
catch (KeyNotFoundException ex)
{
return(NotFound(ex.Message));
}
catch (Exception ex)
{
return(Conflict(ex.Message));
}
}
public void CreateRecordTest()
{
var Message = new RecordDto
{
FirstName = "FNTest",
LastName = "LNTest",
Color = "White",
Gender = "MaleTest",
};
var result = _recordTestController.CreateRecords(Message).GetAwaiter().GetResult();
Assert.True(result is OkObjectResult && (bool)(result as OkObjectResult).Value);
}
public void SaveRecordTest()
{
RecordsController recordsController = new RecordsController(_mockRecordService.Object);
RecordDto recordDto = new RecordDto()
{
LastName = "Gates",
FirstName = "Bill",
Gender = "Male",
FavoriteColor = "Blue",
DateOfBirth = "10/28/1955"
};
var success = recordsController.Post(recordDto);
Assert.IsTrue(success);
}
public void Write_ValueNotEmpty_Received()
{
RecordDto record = new RecordDto
{
Value = "boyner.com.tr",
Type = "String",
ApplicationName = "console",
Name = "site"
};
var manager = new ConfigurationReader(applicationName, "hede", 10, _configurationStorageFactory, _cacheManagerFactory, _configurationStorage);
manager.Write(record);
_configurationStorage.Received().Add(Arg.Any <ConfigurationRecord>());
_cacheManager.Received().Remove("applicationA");
}
