public string SaveContractType(ContractTypeModels contractTypeModel)
{
ContractTypeDTO contractType = new ContractTypeDTO();
MessageDTO message = new MessageDTO();
contractType.Company = new CompanyDTO {
CompanyId = Convert.ToInt32(contractTypeModel.CompanyId)
};
contractType.User = new UserDTO {
UserId = Convert.ToInt32(contractTypeModel.UserId)
};
contractType.ContractTypeDescription = contractTypeModel.ContractTypeDescription;
contractType.ContractTypeId = Convert.ToInt32(contractTypeModel.Id);
contractType.ContractTypeStatus = contractTypeModel.ContractTypeStatus;
if (String.Compare(contractTypeModel.Operation, "add", StringComparison.Ordinal) == 0)
{
message = business.SaveContractType(contractType, "I");
}
else if (String.Compare(contractTypeModel.Operation, "edit", StringComparison.Ordinal) == 0)
{
message = business.SaveContractType(contractType, "U");
}
JavaScriptSerializer oSerializer = new JavaScriptSerializer();
string sJSON = oSerializer.Serialize(message);
return(sJSON);
}
public async Task <OperationDetails> CreateContractTypeAsync(ContractTypeDTO contractTypeDto, OperationDetails MessageSuccess, OperationDetails MessageFail)
{
return((await service.CreateItemAsync(contractTypeDto,
new ContractTypeEquelSpecification(contractTypeDto).ToExpression(),
MessageSuccess,
MessageFail)).Item1);
}
public ContractViewDTO()
{
Contract = new ContractDTO();
ContractType = new ContractTypeDTO();
UserView = new UserViewDTO();
RealEstateView = new RealEstateViewDTO();
Employee = new EmployeeDTO();
}
public ContractTypeDTO updateContractType(ContractTypeDTO contractType)
{
var selectedContractType = uow.GetRepository <ContractType>().Get(z => z.Id == contractType.Id);
selectedContractType = MapperFactory.CurrentMapper.Map(contractType, selectedContractType);
uow.GetRepository <ContractType>().Update(selectedContractType);
uow.SaveChanges();
return(MapperFactory.CurrentMapper.Map <ContractTypeDTO>(selectedContractType));
}
public async Task <OperationDetails> UpdateContractTypeAsync(ContractTypeDTO contractTypeDto, OperationDetails MessageSuccess, OperationDetails MessageFail)
{
int idTypeDto = contractTypeDto.ContractTypeID;
return(await service.UpdateItemAsync(contractTypeDto,
idTypeDto,
MessageSuccess,
MessageFail));
}
public HttpResponseMessage Get(int Id)
{
ContractTypeDTO selectedTitle = service.getContractType(Id);
if (selectedTitle == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, Id + sysLanguage.CompanyTitlesControllerStrings.id_title));
}
return(Request.CreateResponse(HttpStatusCode.OK, selectedTitle));
}
/// <summary>
///
/// </summary>
/// <param name="whereClause"></param>
/// <param name="dataTable"></param>
/// <returns></returns>
public List <ContractTypeDTO> GetContractTypes(Dictionary <string, string> whereClause, ref DataTable dataTable)
{
DataSet dataSet = new DataSet();
IUniversalConnector connector = new UniversalConnectorImpl(ServerEnumType.SqlServer, connectionString);
var contractTypes = new List <ContractTypeDTO>();
int companyId = Convert.ToInt32(whereClause["companyId"]);
int pageSize = Convert.ToInt32(whereClause["pageSize"]);
int pageNumber = Convert.ToInt32(whereClause["pageNumber"]);
string sortColumn = whereClause["sortColumn"].ToString();
string sortOrder = whereClause["sortOrder"].ToString();
try
{
//Todos los registros
object[] parameters = new object[] { companyId, pageSize, pageNumber, sortColumn, sortOrder };
connector.FillDataSet(dataSet, CommandType.StoredProcedure, "GetContractTypes", parameters);
if (dataSet.Tables[1].Rows.Count > 0)
{
dataTable = dataSet.Tables[0];
foreach (DataRow row in dataSet.Tables[1].Rows)
{
ContractTypeDTO contractType = new ContractTypeDTO
{
Company = new CompanyDTO {
CompanyId = Convert.ToInt32(row["COMPANY_ID"])
},
ContractTypeDescription = row["CONTRACT_TYPE_DESCRIPTION"].ToString(),
ContractTypeId = Convert.ToInt32(row["CONTRACT_TYPE_ID"]),
ContractTypeStatus = row["CONTRACT_TYPE_STATUS"].ToString()
};
contractTypes.Add(contractType);
}
}
else
{
contractTypes = null;
}
}
catch (Exception exception)
{
contractTypes = null;
}
finally
{
connector.Dispose();
}
return(contractTypes);
}
public HttpResponseMessage Put(ContractTypeDTO contractTypeDTO)
{
ContractTypeDTO dto = service.updateContractType(contractTypeDTO);
if (dto != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, dto));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.SeeOther, sysLanguage.CompanyTitlesControllerStrings.update_title));
}
}
public ContractTypeDTO newContractType(ContractTypeDTO contractType)
{
if (!uow.GetRepository <ContractType>().GetAll().Any(z => z.Id == contractType.Id))
{
var adedContractType = MapperFactory.CurrentMapper.Map <ContractType>(contractType);
adedContractType = uow.GetRepository <ContractType>().Add(adedContractType);
uow.SaveChanges();
return(MapperFactory.CurrentMapper.Map <ContractTypeDTO>(adedContractType));
}
else
{
return(null);
}
}
private async void InokeAsyncMethods(Object stateInfo)
{
ViewModeUser = MiddleModel.User != null ? false : true;
ViewModeRealEstate = MiddleModel.RealEstate != null ? false : true;
TbDateContract = DateTime.Now.ToShortDateString();
ContractTypeDTO contractType = (await new ContractTypeService().GetAllContractTypes()).Where(c => c.ContractTypeID == (MiddleModel.RealEstate != null ? 1 : 2)).FirstOrDefault();
TbTypeContract = contractType.ContractTypeName;
Contract.ContractTypeID = contractType.ContractTypeID;
TbPost = (await new EmployeePostService().GetAllPosts())
.Where(ep => ep.EmployeePostID == MiddleModel.Employee.Person.EmployeePostID)
.FirstOrDefault()
.EmployeePostName;
}
public HttpResponseMessage Post(ContractTypeDTO contractTypeDTO)
{
ContractTypeDTO dto = service.newContractType(contractTypeDTO);
if (dto != null)
{
HttpResponseMessage message = Request.CreateResponse(HttpStatusCode.Created, dto);
message.Headers.Location = new Uri(Request.RequestUri + "/" + dto.Id);
return(message);
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.SeeOther, sysLanguage.CompanyTitlesControllerStrings.add_title));
}
}
//string connectionString = ConfigurationManager.ConnectionStrings["ConnectionTA"].ToString();
#endregion
#region ContractType
/// <summary>
///
/// </summary>
/// <param name="contractType"></param>
/// <param name="operation"></param>
/// <returns></returns>
public MessageDTO SaveContractType(ContractTypeDTO contractType, string operation)
{
DataTable dataTable = new DataTable();
IUniversalConnector connector = new UniversalConnectorImpl(ServerEnumType.SqlServer, connectionString);
MessageDTO message = new MessageDTO();
try
{
connector.BeginTransaction();
//Todos los registros
object[] parameters = new object[] { contractType.Company.CompanyId, contractType.ContractTypeId,
contractType.User.UserId, contractType.ContractTypeDescription,
contractType.ContractTypeStatus, operation };
//connector.ExecuteNonQuery(CommandType.StoredProcedure, "SaveCharge", parameters);
dataTable = connector.ExecuteDataTable(CommandType.StoredProcedure, "SaveContractType", parameters);
foreach (DataRow row in dataTable.Rows)
{
message.ErrorCode = row["ERROR_NUMBER"].ToString();
message.ErrorMessage = row["ERROR_DESCRIPTION"].ToString();
}
if (message.ErrorCode == "0")
{
connector.Commit();
}
else
{
connector.RollBack();
}
}
catch (Exception exception)
{
message.ErrorCode = "-1";
message.ErrorMessage = exception.ToString();
connector.RollBack();
}
finally
{
connector.Dispose();
}
return(message);
}
public string DeleteContractType(int contractTypeId, int companyId, int userId)
{
ContractTypeDTO contractType = new ContractTypeDTO();
MessageDTO message = new MessageDTO();
contractType.Company = new CompanyDTO {
CompanyId = companyId
};
contractType.User = new UserDTO {
UserId = userId
};
contractType.ContractTypeDescription = "";
contractType.ContractTypeId = contractTypeId;
contractType.ContractTypeStatus = "";
message = business.SaveContractType(contractType, "D");
JavaScriptSerializer oSerializer = new JavaScriptSerializer();
string sJSON = oSerializer.Serialize(message);
return(sJSON);
}
public async Task <OperationDetails> UpdateType(ContractTypeDTO TypeDto)
{
return(await contractTypeService.UpdateContractTypeAsync(TypeDto,
new ContractTypeMessageSpecification(TypeDto).ToSuccessUpdateMessage(),
new ContractTypeMessageSpecification(TypeDto).ToFailUpdateMessage()));
}
public ContractTypeMessageSpecification(ContractTypeDTO typeDto = null)
{
TypeDto = typeDto;
}
/// <summary>
///
/// </summary>
/// <param name="contractType"></param>
/// <param name="operation"></param>
/// <returns></returns>
public MessageDTO SaveContractType(ContractTypeDTO contractType, string operation)
{
return(contractTypeDao.SaveContractType(contractType, operation));
}
