/// <summary>
/// This creates a group for contacts.
/// </summary>
/// <param name="groupName">Name of the group.</param>
/// <returns></returns>
public GroupResponseModel CreateGroup(string groupName)
{
var responseModel = new GroupResponseModel();
try
{
var json =
JsonConvert.SerializeObject(
_groupModelFactory.BuildGroupRequestModel(null, groupName),
new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
int httpStatusCode;
var responseJson = ExecuteRequest(Encoding.UTF8, json, Endpoints.GroupCreate, out httpStatusCode);
var responseObject = JsonConvert.DeserializeObject <GroupResponseModel>(responseJson);
responseObject.HttpStatusCode = httpStatusCode;
return(responseObject);
}
catch (WebException we)
{
responseModel.Exception = we;
responseModel.HttpStatusCode = ((HttpWebResponse)we.Response).GetHttpStatusCode();
}
catch (Exception e)
{
responseModel.Exception = e;
}
return(responseModel);
}
private void DisplayTags_AutoUpdate(GroupResponseModel info)
{
try
{
if (_listTags == null || _listTags.Count == 0)
{
return;
}
var group = _listTags[0].Group.Name;
var server = _listTags[0].Server.Name;
if (info.Group.Name != group || info.Server.Name != server)
{
return;
}
foreach (var tag in info.Tags)
{
if (_listTags.Exists(x => x.Name == tag.Name))
{
var item = _listTags.Find(x => x.Name == tag.Name);
item.Value = tag.Value;
item.Quality = tag.Quality;
}
}
lvTag.Items.Refresh();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public async Task <IActionResult> Post([FromBody] GroupCreateUpdateRequestModel model)
{
var group = model.ToGroup(_currentContext.OrganizationId.Value);
var associations = model.Collections?.Select(c => c.ToSelectionReadOnly());
await _groupService.SaveAsync(group, associations);
var response = new GroupResponseModel(group, associations);
return(new JsonResult(response));
}
public async Task <IActionResult> Get(Guid id)
{
var group = await _groupRepository.GetByIdAsync(id);
if (group == null || group.OrganizationId != _currentContext.OrganizationId)
{
return(new NotFoundResult());
}
var response = new GroupResponseModel(group);
return(new JsonResult(response));
}
//
public bool ResponseTag(GroupResponseModel model)
{
try
{
model.RequestType = RequestType.ReadTag;
var jsonText = JsonConvert.SerializeObject(model);
WriteValue(jsonText);
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <IActionResult> Get(Guid id)
{
var groupDetails = await _groupRepository.GetByIdWithCollectionsAsync(id);
var group = groupDetails?.Item1;
if (group == null || group.OrganizationId != _currentContext.OrganizationId)
{
return(new NotFoundResult());
}
var response = new GroupResponseModel(group, groupDetails.Item2);
return(new JsonResult(response));
}
public bool ResponseGroupTags(GroupResponseModel tags)
{
try
{
tags.RequestType = RequestType.ReadGroupTags;
var jsonText = JsonConvert.SerializeObject(tags);
WriteValue(jsonText);
return(true);
}
catch (Exception)
{
return(false);
}
}
public GroupResponseModel Get(long id)
{
Group group = groupService.Get(id);
IEnumerable <Valve> valves = new List <Valve>();
if (group != null)
{
List <long> valveIds = valveGroupMappingService.GetListByGroup(group.Id).Select(x => x.ValveId).ToList();
valves = valveIds.Count() != 0 ? valveService.GetListByIds(valveIds) : valves;
}
GroupResponseModel responseModel = ModelBinder.Instance.ConvertToGroupResponseModel(group, valves);
return(responseModel);
}
public async Task <IActionResult> Put(Guid id, [FromBody] GroupCreateUpdateRequestModel model)
{
var existingGroup = await _groupRepository.GetByIdAsync(id);
if (existingGroup == null || existingGroup.OrganizationId != _currentContext.OrganizationId)
{
return(new NotFoundResult());
}
var updatedGroup = model.ToGroup(existingGroup);
var associations = model.Collections?.Select(c => c.ToSelectionReadOnly());
await _groupService.SaveAsync(updatedGroup, associations);
var response = new GroupResponseModel(updatedGroup, associations);
return(new JsonResult(response));
}
//public GroupDTO ConvertToGroupDTO(Group entity, IEnumerable<Valve> valves)
//public GroupDTO ConvertToGroupDTO(Group entity, IEnumerable<ValveDTO> valves)
//{
// if (entity == null)
// return null;
// var result = new GroupDTO()
// {
// Id = entity.Id,
// IsActive = entity.IsActive,
// Duration = entity.Duration,
// Name = entity.Name,
// Unit = entity.Unit,
// Valves = valves
// };
// return result;
//}
//public GroupDTO ConvertToGroupDTO(InsertGroupRequestModel requestModel,IEnumerable<ValveDTO> valves)
//{
// var result = new GroupDTO()
// {
// IsActive = true,
// Duration = requestModel.Duration,
// Name = requestModel.Name,
// Unit = requestModel.Unit,
// Valves = valves
// //Valves =valves.Select(x=>ConvertToValve(x))
// };
// return result;
//}
//public GroupDTO ConvertToGroupDTO(UpdateGroupRequestModel requestModel, IEnumerable<ValveDTO> valves)
//{
// var result = new GroupDTO()
// {
// Id = requestModel.GroupId,
// IsActive = true,
// Duration = requestModel.Duration,
// Name = requestModel.Name,
// Unit = requestModel.Unit,
// Valves = valves
// //Valves = requestModel.ValveIdList != null ?
// // valves.Where(x => x.IsActive && requestModel.ValveIdList.Contains(x.Id)).Select(x => ConvertToValve(x)) :
// // new List<Valve>()
// };
// return result;
//}
public GroupResponseModel ConvertToGroupResponseModel(Group entity, IEnumerable <Valve> valves)
{
if (entity == null)
{
return(null);
}
GroupResponseModel result = new GroupResponseModel {
Id = entity.Id,
Duration = entity.Duration,
Name = entity.Name,
Unit = entity.Unit,
Valves = valves
};
return(result);
}
public IEnumerable <GroupResponseModel> GetList()
{
IEnumerable <Group> groupItems = groupService.GetList();
IEnumerable <ValveGroupMapping> totalGroupValveMappingList = valveGroupMappingService.GetList();
IEnumerable <Valve> totalValveList = valveService.GetList();
List <GroupResponseModel> resultList = new List <GroupResponseModel>();
foreach (Group group in groupItems)
{
List <long> valveIds = totalGroupValveMappingList.Where(x => x.GroupId == group.Id).Select(x => x.ValveId).ToList();
IEnumerable <Valve> valve = totalValveList.Where(x => valveIds.Contains(x.Id));
GroupResponseModel tempResponseItem = ModelBinder.Instance.ConvertToGroupResponseModel(group, valve);
resultList.Add(tempResponseItem);
}
return(resultList);
}
public GroupResponseModel Insert(InsertGroupRequestModel requestModel)
{
Group groupItem = ModelBinder.Instance.ConvertToGroup(requestModel);
groupItem = groupService.Insert(groupItem);
IEnumerable <Valve> valves = valveService.GetListByIds(requestModel.ValveIdList.ToList());
foreach (Valve valve in valves)
{
valveGroupMappingService.Insert(
new ValveGroupMapping {
IsActive = true,
GroupId = groupItem.Id,
ValveId = valve.Id
});
}
GroupResponseModel resultModel = ModelBinder.Instance.ConvertToGroupResponseModel(groupItem, valves);
return(resultModel);
}
public GroupResponseModel Update(UpdateGroupRequestModel requestModel)
{
Group group = ModelBinder.Instance.ConvertToGroup(requestModel);
group = groupService.Update(group);
IEnumerable <ValveGroupMapping> existedMappings = valveGroupMappingService.GetListByGroup(group.Id);
// delete mapping
foreach (ValveGroupMapping item in existedMappings)
{
if (!requestModel.ValveIdList.Contains(item.ValveId))
{
valveGroupMappingService.Delete(item.Id);
}
}
// insert mapping
IEnumerable <Valve> latesValves = valveService.GetListByIds(requestModel.ValveIdList.ToList());
IEnumerable <long> mappedValveIds = existedMappings.Select(x => x.ValveId);
foreach (Valve item in latesValves)
{
if (!mappedValveIds.Contains(item.Id))
{
valveGroupMappingService.Insert(
new ValveGroupMapping {
IsActive = true,
GroupId = group.Id,
ValveId = item.Id
});
}
}
GroupResponseModel resultModel = ModelBinder.Instance.ConvertToGroupResponseModel(group, latesValves);
return(resultModel);
}
public bool ReceiveGroupTags(GroupResponseModel info)
{
try
{
var model = new GroupResponseModelRpc_Request();
model.Server = new ServerModelRpc {
Name = info.Server.Name, IsConnected = info.Server.IsConnected
};
model.Group = new GroupModelRpc()
{
Name = info.Group.Name, Active = info.Group.Active
};
model.Tags = new RepeatedField <TagModelRpc>();
var tags = new BindingList <TagModelRpc>();
foreach (var tag in info.Tags)
{
tags.Add(new TagModelRpc()
{
Name = tag.Name,
Value = int.Parse(tag.Value.ToString()),
Quality = tag.Quality
});
}
model.Tags.Add(tags);
var res = _rpcClient.ReceiveGroupTags(model);
return(true);
}
catch (Exception ex)
{
if (ex.Message.Contains("StatusCode=Unavailable"))
{
_connected = false;
}
}
return(false);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
//return;
using (IServiceScope scope = scopeFactory.CreateScope()) {
var valveService = scope.ServiceProvider.GetRequiredService <IValveProcedure>();
IProfileProcedure profileService = scope.ServiceProvider.GetRequiredService <IProfileProcedure>();
IGroupProcedure groupService = scope.ServiceProvider.GetRequiredService <IGroupProcedure>();
//PinController pinController = scope.ServiceProvider.GetRequiredService<PinController>();
MainController settingsController = scope.ServiceProvider.GetRequiredService <MainController>();
valveService.GetList().ToList().ForEach(
valve => {
EasyRequest($"http://localhost:5000/api/v1/Pin/Close/{valve.Id}");
});
Console.Clear();
while (!stoppingToken.IsCancellationRequested)
{
//todo check for is whole system is active
//if not, turn off all open valves
GgSettings settings = settingsController.Get().Value;
if (settings.IsStarted)
{
List <ProfileResponseModel> profiles = profileService.GetList().ToList();
List <ProfileResponseModel> todaysProfiles = GetTodaysProfiles(profiles);
List <ProfileResponseModel> startTimePassedProfiles = GetStartTimePassedProfiles(todaysProfiles);
List <ProfileResponseModel> totalTimeIsNotPassedProfiles = GetTotalTimeIsNotPassedProfiles(startTimePassedProfiles);
IOrderedEnumerable <ProfileResponseModel> orderedTodaysProfiles = totalTimeIsNotPassedProfiles.OrderBy(o => o.StartHour).ThenBy(o => o.StartMinute);
List <Valve> valvesToBeOpen = new List <Valve>();
foreach (ProfileResponseModel profile in orderedTodaysProfiles)
{
//DateTime profileEndTime = GetProfileEndTime(profile);
//if (DateTime.Now.CompareTo(profileEndTime) >= 0) {
// continue;
//}
List <Group> profileGroups = profile.Groups.ToList();
int passedTime = (DateTime.Now.Hour * 60 + DateTime.Now.Minute - profile.StartHour * 60 - profile.StartMinute);
for (int i = profileGroups.Count - 1; i >= 0; i--)
{
GroupResponseModel g = groupService.Get(profileGroups[i].Id);
if (passedTime < profileGroups[i].Duration)
{
valvesToBeOpen.AddRange(g.Valves);
break;
}
else
{
//foreach (Valve valve in g.Valves) {
// //EasyRequest($"http://localhost:5000/api/v1/Pin/Close/{valve.Id}");
// //pinController.Close(valve.Id);
//}
passedTime -= profileGroups[i].Duration;
}
}
}
valvesToBeOpen.ForEach(valve => EasyRequest($"http://localhost:5000/api/v1/Pin/Open/{valve.Id}"));
await Task.Delay(1000 * 5, stoppingToken);
List <ValveResponseModel> valves = valveService.GetList().ToList();
foreach (ValveResponseModel valve in valves)
{
if (!valvesToBeOpen.Exists(o => o.Id == valve.Id))
{
EasyRequest($"http://localhost:5000/api/v1/Pin/Close/{valve.Id}");
}
}
}
await Task.Delay(1000 * 10, stoppingToken);
}
}
}
public ActionResult <GroupResponseModel> Post([FromBody] InsertGroupRequestModel requestModel)
{
GroupResponseModel result = _procedure.Insert(requestModel);
return(result);
}
public ActionResult <GroupResponseModel> Get(long id)
{
GroupResponseModel result = _procedure.Get(id);
return(result);
}
public ActionResult <GroupResponseModel> Put([FromBody] UpdateGroupRequestModel requestModel)
{
GroupResponseModel result = _procedure.Update(requestModel);
return(result);
}
