use crate::helper::ask_response_to_submsg;

use cosmwasm_std::{Attribute, from_binary};

use cw_storage::msg::BucketResponse;

use cw_storage::msg::ExecuteMsg::StoreObject;

use logic_bindings::{AskResponse, Substitution};

use crate::helper::get_reply_event_attribute;

use crate::state::{PROGRAM, Object};

deps: DepsMut<'_, LogicCustomQuery>,

let context = INSTANTIATE_CONTEXT.load(deps.storage)?;

msg.result.into_result()

.map_err(|_| ContractError::EmptyReply)

.and_then(|e| get_reply_event_attribute(e.events, "id".to_string()).ok_or(ContractError::NoObjectId))

.map(|obj_id| Object {

object_id: obj_id.to_string(),

storage_address: context.0.clone()

})

.and_then(|obj| -> Result<(), ContractError> {

PROGRAM.save(deps.storage, &obj).map_err(|e| ContractError::from(e))

})

.and_then(|_| -> Result<AskResponse, ContractError> {

let req = LogicCustomQuery::Ask { program: from_binary(&context.1)?, query: "source_files(Files).".to_string() }.into();

deps.querier.query(&req).map_err(|e| ContractError::from(e))

})

.and_then(|res| ask_response_to_submsg(res, context.0, "Files".to_string()))

.map(|msg| {

// Clean instantiate context

INSTANTIATE_CONTEXT.remove(deps.storage);

Response::new()

.add_submessages(msg)

})

use cosmwasm_std::{from_binary, to_binary, CosmosMsg, Order, SubMsgResponse, SubMsgResult, SystemError, SystemResult, Event, Attribute};

events: vec![

Event::new("e".to_string()).add_attribute("id".to_string(), case.object_id.clone())

],

data: None,

// Configure the instantiate context

let program = to_binary("foo(_) :- true.").unwrap();

INSTANTIATE_CONTEXT.save(deps.as_mut().storage, &("okp41dclchlcttf2uektxyryg0c6yau63eml5q9uq03myg44ml8cxpxnqavca4s".to_string(), program)).unwrap();

let response = reply::store_program_reply(deps.as_mut(), mock_env(), reply);

let res = response.unwrap();

#[error("Could not find ObjectId of stored program")]

NoObjectId,

#[error("Empty data on reply")]

EmptyReply,

#[error("Invalid reply message: {0}")]

InvalidReplyMsg(StdError),

use std::env::var;

use cosmwasm_std::{Attribute, Event, SubMsg, to_binary, WasmMsg};

use logic_bindings::{AskResponse, Substitution};

use crate::ContractError;

use crate::state::Object;

use cw_storage::msg::ExecuteMsg as StorageMsg;

use crate::ContractError::NotImplemented;

pub fn get_reply_event_attribute(events: Vec<Event>, key: String) -> Option<String> {

let r = events.iter()

.flat_map(|e| e.attributes.clone())

.filter(|a| a.key == key)

.map(|a| a.value)

.collect::<Vec<String>>();

if r.len() > 0 { Some(r[0].clone())} else { None }

fn filter_source_files(substitution: Substitution) -> Vec<String> {

substitution.term.name.split(",")

.into_iter()

.map(|s| s.replace(&['\'', '[', ']'], ""))

.collect::<Vec<String>>()

fn uri_to_object(uri: String) -> Result<Object, ContractError> {

Err(NotImplemented {})

pub fn ask_response_to_submsg(res: AskResponse, storage_addr: String, variable: String) -> Result<Vec<SubMsg>, ContractError> {

let uris = res.answer

.map(|a| a.results)

.unwrap_or(vec![])

.iter()

.flat_map(|result| result.substitutions.clone())

.filter(|s| s.variable == variable)

.flat_map(|s| filter_source_files(s))

.collect::<Vec<String>>();

let mut msgs = vec![];

for uri in uris {

let object = uri_to_object(uri)?;

let msg = WasmMsg::Execute {

contract_addr: storage_addr.to_string(),

msg: to_binary(&StorageMsg::PinObject {

id: object.object_id,

})?,

funds: vec![],

};

msgs.push(SubMsg::new(msg))

}

return Ok(msgs)

mod helper;